我们是个小型创业公司，现在要一台高端又经济实惠的商务接待车，有比较合适的车型吗？看了别克GL8觉得有点贵，有性价比高一点的车推荐吗(我们是做硅胶模具的，怎样区分S50C 与P20钢材)

我们是个小型创业公司，现在要一台高端又经济实惠的商务接待车，有比较合适的车型吗？看了别克GL8觉得有点贵，有性价比高一点的车推荐吗 ♂

我们是个小型创业公司，现在要一台高端又经济实惠的商务接待车，有比较合适的车型吗？看了别克GL8觉得有点贵，有性价比高一点的车推荐吗

高端品牌不存在经济实惠,有性价比高一点的车推荐吗20万左右的MPV里别克GL8不是理想的选择,开什么车才低调又豪华限30万左右我们是个小型创业公司,是一台来自豪华品牌的商务接待车,开什么车才低调又豪华限30万左右40岁,对于一台MPV来说有这些配置价格仅在20万左右是合格的,这台车的卖点主要是舒适性很高,一眼看去就是车不便宜。

• 我们是个小型创业公司，现在要一台高端又经济实惠的商务接待车，有比较合适的车型吗
• 看了别克GL8觉得有点贵，有性价比高一点的车推荐吗
• 40岁男人，开什么车才低调又豪华限30万左右

谢邀

我是木子李，一名资深二手车鉴定师。

作为一个小型的创业公司，我想你的资金不会宽裕，这种情况下，入手二手商务车就比较合适。

首先我先来分析一下你的问题，你所说的高端，它有两种意思。

一种是显得高端。显得高端的车子我给你推荐准新的广汽传祺GM8，国产商务车。内部空间够大，接待客户没问题，内饰做工很细致，特别显高端，同时又因为它是一台国产车，配件便宜，维修保养也相对便宜。符合你经济实惠的要求。唯一的缺点就是因为它是国产品牌，接待大客户是否有些不妥，还请自行斟酌。目前它在二手车市场，准新车况20左右。

还有即将上市的上汽大通G20，同GM8一样，我就不过多赘述了。

我看到回答区好多人给你推荐GL8，作为国内商务车流通最高的车型，它显然符合大多数人对一台商务车的定义，老款的胖头鱼版本，也在二十来万的价格区间，不过我并不推荐入手老款。因为跟新款GL8 ES版本比起来，老款的性价比太低，而且GL8作为调表车的重灾区，还是要多看看车况如何，避免踩雷。新款ES版本在二手车市场30万左右。预算高一些。

还有一种就是品牌高端，高端品牌不存在经济实惠。

我给你推荐的，是一台来自豪华品牌的商务接待车，奔驰R级，R300。进口车型。目前行情25万左右可以买到一台2013款的。

奔驰这个品牌不用多说，中国市场老牌豪华品牌，它的品牌溢价能力说明了它还是很有面子的，用来接待大客户再合适不过。商务车型该有的配置，它全部都有，独立分区空调、全景天窗、空间也足够大。

它的缺点就在于，豪华品牌，养车成本相对较高，没有电动侧滑门。平常使用多注意中冷器。

推荐完之后我还想再多说几句。

接待客户用车，千万不要考虑GM6、GL6等小型MPV，作为家用奶爸车，它们是合格的，但是作为商务车，它们的尺寸偏小。去接待客户你宁愿车子后排空着，也不能让客户挤着跟你谈生意吧。

任何一款商务用车，油耗都不会低于10L，所以燃油经济性就别考虑了。

希望能帮到你

20万左右的MPV里别克GL8不是理想的选择，因为只能考虑老款造型的自吸动力，以这个价格作为参考可以考虑自主品牌的中端车型，性价比要远高于合资品牌。

具体车型推荐传祺GM8尊享版或尊贵版，指导价18.98-21.68万，车身尺寸5066*1923*1822、轴距3000mm，七座中型MPV。这台车的卖点主要是舒适性很高，尊享版有单侧电动侧滑门配备中排独立航空座椅，尊贵版为航空座椅加入了按摩通风加热功能、并且升级为双侧电动门，这些配置对于MPV来说是真正可以提高舒适体验的。

其次悬架为前麦弗逊、后多连杆式四轮独立悬架，基本是轿车化的设计，车身姿态的控制可以更精准对于舒适性的提升再加一分。

---

其次动力搭载传祺自主研发的2.0T多点电喷发动机油耗表现不错，配合爱信6AT虽然技术不算领先动力表现也比较一般，但综合路况平均油耗可以控制在百公里12升左右还是值得认可的，这种级别的MPV综合油耗在15升左右都算合格，低于这个成绩可以算优异。

安全配置标配ESP车身稳定系统和全车气囊，尊贵版加入了胎压监测，舒适配置还有双天窗、电动感应尾门等，对于一台MPV来说有这些配置价格仅在20万左右是合格的。

---

低于GL8的预算可以考虑传祺GM8，这台车适合作为家用保姆车；如果以商务用途为主可以考虑尺寸大一号的大通G10，舒适配置逊色一些但空间更大，整车视觉感受也比较中庸得体，车身尺寸5168*1980*1928、轴距3198mm，同样七座布局。

动力建议考虑2.0T-20E4E汽油版，匹配6AT驾乘体验也在一线；1.9T柴油动力是云内发动机，水平和稳定性只能说一般，不过柴油机燃烧效率高省油是显而易见的，如果作为商务通勤用车也可以考虑。

---

这两台车是低于GL8预算内不错的选择，供参考。

---

40岁，低调的车，30万左右，我就按上下浮动3万，裸车的价格来说了。

你想低调且豪华，那基本排除豪华品牌，包括所谓的一线二线，只能从普通合资品牌里选。

推荐之前我想说下评论里推荐的都是什么JB玩应，汉兰达帕杰罗云云，脑袋进水了吗？汉兰达跟低调豪华有关系吗？还有整个硬派越野也能跟低调豪华搭上边？能不能靠点谱啊，真是服气。

1.回归正题，这个价格和要求，我首推大众辉昂。标准的C级车，A6L的平台，纵置布局，虽然是前驱，但好歹也是纵置，包括悬挂结构也更高级，不是普通麦弗逊能比。整车驾控感以及平台用料，在这个价位我认为算得上低调豪华，但这个豪华我指的不是内饰，大众的内饰确实平淡了点，但好在做工挑不出毛病。

2.其它的说实话都不太符合你的要求，勉强金牛座能够的上，但福特的做工不敢恭维，而且现在取消了2.7T，又是横置平台，所以不是很推荐。

3.剩下就是豪华品牌了，包括窝窝s90，林肯大陆以及卡迪CT6。窝窝那个油箱太小，横置平台，内饰确实不错，自己取舍吧。那俩平台布局啥的没问题，车也不错，但跟低调不太搭边，一眼看去就是车不便宜，所以这东西看你自己吧，就要低调这三都不行。

我对低调豪华的理解是表面看一般般，但内在的都是好东西，而且性价比不错，这是我对低调豪华的理解。就比如辉昂，表面一看就一大众，不知道还以为帕萨特呢，实际内在的东西不错。

推荐完毕。

我们是做硅胶模具的，怎样区分S50C 与P20钢材 ♂

我们是做硅胶模具的，怎样区分S50C 与P20钢材

• 我们是做硅胶模具的，怎样区分S50C 与P20钢材
• s50c是什么材料
• S50C是什么材料，是不是就是45钢
• S50C钢材是什么材质
• s50c与65mn这两种材料的区别，使用会不会影响产品性能
• s50c材料硬度比304不锈钢硬吗
• S45C 和S50C 的区别
• s50chb150是啥意思钢材是s50cHB150
• S50C热处理最高能达到多少度/HRC

S50C钢材为高强度中碳钢，冷变形塑性低、焊接性能、淬透性差，但无回火脆性，切削性能尚可。一般在正火或淬火、回火下使用，用于制造耐磨性要求高，动载荷及冲击作用不大的机械加工件和弹簧件，如锻造齿轮、拉杆、轧辊、轴、摩擦盘、农用掘土犁铧、重负荷心轴等。
热处理规范：正火,830℃;淬火,830℃;回火,600℃。 　　金相组织：珠光体+铁素体。
　P20钢材是一种模具焊材的型号，最早的是P20，紧接着P20H，P20Ni相继问世。 P20钢材适用于制作塑料模和压铸低熔点金属的模具材料。此钢具有良好的可切削性及镜面研磨性能。

S50C是日本JIS标准优质碳素钢
相当中国GB:50#钢
S50C化学成分（质量分数，%）：
碳：C 0.47~0.53、
硅：Si 0.15~0.35、
锰：Mn 0.60~0.90、
磷：P≤0.030、
硫：S≤0.035、
铜：Cu≤0.30、
镍：Ni≤0.20、
铬：Cr≤0.20.
S50C力学性能：
抗拉强度 σb (MPa)：≥630(64)
屈服强度 σs (MPa)：≥375(38)
伸长率 δ5 (%)：≥14
断面收缩率 ψ (%)：≥40
冲击功 Akv (J)：≥31(4)
冲击韧性值 αkv (J/cm2)：≥39(4)
硬度 ：未热处理，≤241HB;退火钢，≤207HB

日本山阳叫PC50,S50C是日本JIS标准优质高碳钢，国标是50#号钢，也就是大家口中的50号王牌。S50C不是45#钢，S50C比45#钢高一级，碳的成份比45#钢足。

s50c碳素结构钢属于高级优质中碳钢，s50c碳钢采用由电平炉或纯氧转炉炼钢法制造的全静钢，s50c碳钢具有进行组织均匀的特点，s50c碳素工具钢钢含碳量≥0.4，耐磨性优良，延展性减少，淬火易变形和开裂。
p20是经过vad处理技术生产的优质塑料模具钢，gb标准名称为3cr2mo模具钢，p20的综合力学性能较好、淬透性高、可以使截面尺寸较大的钢材获得较均匀的硬度。具有很好的抛光性能，制成模具的表面粗糙度值低。

S50C是日本JIS标准优质高碳钢，国标是50#号钢。
该为中碳高强度碳素结构钢，淬火后具有高的强度和硬度，该钢可切削性中等，冷变形塑性低，焊接性差，热处理时无回火脆性，但淬透性较低，水中临界直径为13*30mm，且水淬时有开裂倾向。此钢通常在正火或淬火回火，或高频表面淬火等热处理后使用。
50号钢可以淬硬至HRC42~46。所以如果需要表面硬度，又希望发挥50号钢优越的机械性能，常将50号钢表面渗碳淬火，这样就能得到需要的表面硬度。
化学成分：
.C
0.47~0.55、Si
0.17~0.37、Mn
0.50~0.80、P≤0.035、S≤0.035、Ni≤0.30、Cr≤0.15、Cu≤0.25。
65Mn弹簧钢，锰提高淬透性，φ12mm的钢材油中可以淬透，表面脱碳倾向比硅钢小，经热处理后的综合力学性能优于碳钢，但有过热敏感性和回火脆性。用作小尺寸各种扁、圆弹簧、座垫弹簧、弹簧发条，也可制作弹簧环、气门簧、离合器簧片、刹车弹簧及冷拔钢丝冷卷螺旋弹簧。
65mn
强度.硬度.弹性和淬透性均比50号钢高，具有过热敏感性和回火脆性倾向，水淬有形成裂纹倾向。退火态可切削性尚可，冷变形塑性低，焊接性差。
受中等载荷的板弹簧，直径达7-20mm的螺旋弹簧及弹簧垫圈.弹簧环。高耐磨性零件，如磨床主轴.弹簧卡头.精密机床丝杆.切刀.螺旋辊子轴承上的套环.铁道钢轨等。
●化学成份：
　　碳
C
：0.62～0.70
　　硅
Si：0.17～0.37
　　锰
Mn：0.90～1.20
　　硫
S
：≤0.035
　　磷
P
：≤0.035
　　铬
Cr：≤0.25
　　镍
Ni：≤0.25
　　铜
Cu：≤0.25。
同等硬度下，65MN的单价也比50#的要高。
综上所述，两款材料不能等同使用。

硬度都是可以经过各种加工增加的，304材料不经过加工的硬度也就是软态在200HV不到，另外那材料不清楚，不过据我所知304冷轧后硬度就能做到480HV左右。

s45C
该钢含碳量在0.4%以上，耐磨性优良，但延展性减少，淬火易变形和开裂，故热处理极为重要，且回火后必须急冷，以避免回火脆性发生。通过对该钢实行球化处理，可以改善这类碳钢的切削性能。45C广泛用于机械制造，这种钢的机械性能很好。但是这是一种中碳钢，淬火性能并不好， 45号钢可以淬硬至HRC42~46。所以如果需要表面硬度，又希望发挥45#钢优越的机械性能，常将45#钢表面渗碳淬火，这样就能得到需要的表面硬度。
S55C
　日本钢材牌号。日本钢材都以S开头。S55C相当于中国优质碳素结构钢55#钢。与45#钢一样属于中碳钢 　　（1）特性 高级优质中碳钢。该钢是由电炉、平炉或纯氧转炉炼钢法制造的全静钢，具有加工性优良、金相组织均匀的特点。该钢价格便宜，加工容易，适合于高频淬火、火焰淬火等表面硬化处理。该钢含碳量（质量分数，%）≥0.4，耐磨性优良，但延展性减少，淬火易变形和开裂，故淬火极为重要，且回火后必须急冷，以避免发生回火脆性。该钢切削困难，需进行球化处理改善切削性能，原则上回火到硬度19~22HRC，以利于机械加工

s50C是日本黄牌模具钢的称呼，其实跟45#差不多了，HB是硬度150度（布氏硬度）

S50C热处理最高能达到HRC55左右，但是这种情况材料容易开裂，韧性差。
S50C一般在调质状态使用，一定要淬火的话淬火硬度不要超过HRC50.

相关tag:钢材 s50c材料硬度
本站部分资源来源于网络，如果侵犯了您的权益，请联系我们删除1354090129@qq.com

我们是贵州省，独山县农民！现在国家开发贵州！政府大量低价收购我们土地几万亩卖给开发商，平地良田、 ♂

我们是贵州省，独山县农民！现在国家开发贵州！政府大量低价收购我们土地几万亩卖给开发商，平地良田、

• 我们是贵州省，独山县农民！现在国家开发贵州！政府大量低价收购我们土地几万亩卖给开发商，平地良田、
• 贵州独山县怎么样
• 陆廷壮2021年任独山县什么职务7
• 贵州独山县烧钱建烂尾景区，为什么县城容易出现这种情况
• 独山县破产后怎么办
• 贵州独山县回应烧掉四百亿，独山县400亿应如何偿还

征收耕地的补偿费用包括土地补偿费、安置补助费以及地上附着物和青苗的补偿费。征收耕地的土地补偿费，为该耕地被征收前三年平均年产值的六至十倍。征收耕地的安置补助费，按照需要安置的农业人口数计算。需要安置的农业人口数，按照被征收的耕地数量除以征地前被征收单位平均每人占有耕地的数量计算。每一个需要安置的农业人口的安置补助费标准，为该耕地被征收前三年平均年产值的四至六倍。但是，每公顷被征收耕地的安置补助费，最高不得超过被征收前三年平均年产值的十五倍。

你好，我是土生土长的独山人。近几年独山发展非常快。今年刚升为贵州省经济开发区，其经济实力相对周围的县相对领先，正在飞速发展交通十分便利，有高速公路，铁路，210国道，通往荔波的省道，其火车站前广场是贵州最大的最为豪华的，60米的开发大道是较为大气宽阔的，城区规划很科学，车辆不拥堵。
天气相对省府贵阳凉快，非常适宜人的居住。旅游就不用说了，有三个国家级公园，其还有很多非常漂亮的旅游资源。其到荔波小七孔两个小时。
独山县前身为黔南州，在抗战之前确实非常有名气，有小上海之称，贵州第一飞机场，黄埔军校第四分校，之前城里人已有12万如今只有3,4万，但被日军侵略，烧了七天七夜，成为日军侵华的最后一个地方，可想而知，。。。。素有“北有卢沟桥，南有深河桥”（深河桥在独山）最近正以此背景在拍部电视剧《血色独山》，欢迎了解
教育方面，独山正在建一个大学城，中央音乐学院（211工程），动地中海大学（全英文授课，中外合办），北塞浦路斯国际大学（中外合办），广州大学独山分校，黔南师范独山分校，贵定师范独山分校，黔南医学院独山分校。。。。独山民族中学发展迅速，逐渐有名。上和都匀连成一片成一个较大城市，也可能四五年后会独立为地级市。
希望能帮助您！

摘要现任麻万镇人民政府工作人员,拟任贵州独山金控投资管理有限公司董事。陆廷壮,男,1990年3月出生,大学本科,西北民族大学,2016年8月参加工作,独山县国有资产监督管理委员会关于国企高管。

咨询记录 · 回答于2021-09-25

陆廷壮2021年任独山县什么职务7

现任麻万镇人民政府工作人员,拟任贵州独山金控投资管理有限公司董事。陆廷壮,男,1990年3月出生,大学本科,西北民族大学,2016年8月参加工作,独山县国有资产监督管理委员会关于国企高管。

现任麻万镇人民政府工作人员,拟任贵州独山金控投资管理有限公司董事。陆廷壮,男,1990年3月出生,大学本科,西北民族大学,2016年8月参加工作,独山县国有资产监督管理委员会关于国企高管。

评论收起

因为像独山县这种没有自然资源，地方偏僻的地方要想发展就只能大力发展旅游业。潘志立来独山县工作时曾说过，人生就像“从终点回到起点，——。”贵州现在走的道路是十多年前的沿海发展道路。”“既然来了，就让地方发展少走弯路，培育出一批成熟的发展模式“。据知情人士说，独山县市委的一位官员介绍说，潘志立刚来的时候，大家都觉得他能力一般，“思路清晰，懂经济，有眼光，口才好，很多地方官员，包括我在内，都以为他什么都懂，都是他的粉丝。”

潘志立初到独山时，他的发展思想是务实的，他想大力发展经济，要求每个乡镇都要建一个工业园区。“但是当时的投资并不顺利，一些过来的企业并没有达到预期的效果。”。该县官员还说，潘志立也觉得自己有很强的能力和眼光。后来，他变得过于膨胀，不愿听取反对派的意见，并发表了一个集中声明，“即使是黔南州的领导层，他也不相信。”

独山县是国家级贫困县。自然条件差，基础薄弱，资金少。为了发展经济，地方政府结合地方优势，大力扶持旅游业，多渠道筹集资金，开发许多项目，做许多实事。然而，独山县在借入大量资金从事大型项目的过程中也遇到了一些问题，一个上亿元的旅游开发项目在开工仅五个月后就被迫停工。

其主要手段是借势，借力，借钱。关键在于借贷。如今看来，独山县在潘志立执政时期，几乎是建立了各种各样的融资平台。比如，独山县最多的时候有将近40个融资平台，规模最低的是10亿，最高的是100亿。随后，政府介入，为平台融资项目和企业提供担保。贵州还有很多干部以借债为荣，搞了很多未完工的建筑。新来的干部似乎试图回避问题，假装他们看不到前任留下的债务黑洞。这些新任干部甚至不想留下几个人来维持一点未完成的项目，以便为将来的新练习留下一些进展。中国的经济仍然没有蓬勃发展，它真的负担不起这样的地方干部。

破产清算后债务处理的办法如下： 对破产债权应该按下列顺序进行清偿。
1、破产人所欠职工的工资和医疗、伤残补助、抚恤费用，所欠的应当划入职工个人账户的基本养老保险、基本医疗保险费用，以及法律、行政法规规定应当支付给职工的补偿金
2、破产人欠缴的除前项规定以外的社会保险费用和破产人所欠税款；
3、普通破产债权。如果破产财产不足以清偿同一顺序的清偿要求的，按照比例分配。
一、事实上的破产，主要分为两类：
1：债务人丧失了继续经营事业的财产承受能力；
2：债务人发生了债务清偿不能的财务危机。但是在法律上使用“破产”，是指债务人不能清偿债务时所适用的偿债程序和该程序终结后债务人的身份地位受限制的法律状态。
二、破产特征
（1）债务人不能清偿到期债务
（2）存在多数债权人
（3）债权人公平受偿
（4）免除未能清偿的债务
三、破产两种情况：
（1）申请破产的公司和债权人达成和解协议生效后，由申请破产的公司的上级主管机关负责主持对该公司进行整顿。整顿期限不得超过2年。整顿期满公司能够清偿债务的，可终结破产程序。
（2）公司清算结束后，清算组应当制作清算报告，报股东会或者有关主管机关确认，并报送公司登记机关，申请注销公司登记，公告公司终止。
法律依据：
《中华人民共和国企业破产法》
第一百一十三条　破产财产在优先清偿破产费用和共益债务后，依照下列顺序清偿：
（一）破产人所欠职工的工资和医疗、伤残补助、抚恤费用，所欠的应当划入职工个人账户的基本养老保险、基本医疗保险费用，以及法律、行政法规规定应当支付给职工的补偿金；
（二）破产人欠缴的除前项规定以外的社会保险费用和破产人所欠税款；
（三）普通破产债权。

是发生火灾了吗？天灾人祸为什么要偿还呢？

不好意思，平时不怎么看新闻，对地名也不太敏感，看到问题的第一反应是：贵州，应该多山，有山肯定有树林，澳大利亚火灾还历历在目，难道又有森林火灾发生了吗？2020年果然应该以“生存”作为第一目标，第一要务。希望人没事，希望以后不要再有不好的事情发生。火灾的损失好严重呀，怎么偿还确实是一个大问题，不过应该会有相关的规定，网上应该也可以找到相应的案例参考，还是百度一下吧。

不是火灾？不是天灾？到底发生了什么？四百亿到底从哪里来？四百亿又是从谁手里花出去的？

先看独山县，坐落于贵州最南端，“贵州南大门”，一个街道，八个乡镇，年产值不足十亿。第一观感是，依山傍水的地方可能是想大力发展旅游业，所以不惜融资四百亿投入建设事业，能做出如此举动，领导确实很有魄力，但想想如果不是急于发展经济，应该也不会做出这样的举动，毕竟对于一个家底不厚的地方来说，四百亿真心不是一个小数目呀，原来做出这个决定的人怎么样了呀？为什么看似为发展经济孤注一掷的举动，会成了一个烂摊子，成了一笔人人提起都忍不住摇头的烂账？

做出“四百亿”决策的是，独山县原县委书记潘志立 ，既然是原县委书记，那他现在在哪里？不是升职也不是降职，而是被“双开”了，原因是要面子不要里子，天价造价楼不是为了发展旅游业，，只是为了“形象”。难怪好好的楼没有成为什么当地的旅游招牌，而成了当地的天价债务。

理论上潘志立与四百亿的债脱不了干系，即使他做不到偿还，也必定要为此付出代价，但剩下的债呢？完全让独山县财政偿还，太难！大胆猜测，最后应该会由上级财政帮忙负担。

相关tag:独山县政府破产
本站部分资源来源于网络，如果侵犯了您的权益，请联系我们删除1354090129@qq.com

我们有一亿元可以买兰博基尼和法拉利吗 ♂

我们有一亿元可以买兰博基尼和法拉利吗

• 我们有一亿元可以买兰博基尼和法拉利吗
• 一亿以上的豪车有哪些劳斯莱斯幻影1亿7000万
• 一亿的豪车有什么优缺点
• 兰博基尼 跑车大概一亿多的
• 一个亿可以买多少辆兰博基尼
• 一千亿买什么跑车
• 一亿以上的豪车有哪些

当然可以。兰博基尼最便宜的是盖拉多，，，最少350万就行，，，法拉利最便宜的是加州，，300万也能搞定，，，事实上一亿元世界上所有的量产车和绝大部分非量产车都可以买到，，，目前最贵的车应该是柯尼塞格one：1，，它没有公布准确价格，，但肯定超过一个亿了

??????随着互联网时代的发展，如今几百上千万的豪车对于网友来说似乎都已经算不上“豪”了，所以很多人又开始对更贵的车开始感兴趣，最近就有网友表示想知道有没有售价上亿的车，那么下面就来看看究竟一亿以上的豪车有哪些?
布加迪威龙敞篷版
售价亿元
??????布加迪威龙曾经是世界上最快
??????的车，而威龙的敞篷版则是世界上最快的敞篷车。布加迪威龙敞篷版搭载的是世界独此一家的升W16发动机，配有四个涡轮增压器以及十多个中冷器。最大马力超过1000匹，最高车速可达430km/h，百公里加速只要秒。
??????与这款发动机配合的是一个100L的大油箱，但是如果你以全速行驶这100L的油只能支持25分钟。如此恐怖的高性能跑车也确实只有土豪才能玩得起，据了解施瓦辛格就拥有一辆布加迪威龙敞篷版。
劳斯莱斯定制版幻影Coup
市场价1亿7000万
??????很多人听到劳斯莱斯幻影1亿7000万的时候可能都会觉得过于夸张，毕竟幻影市场价才790-920万。但实际上确实有这样一款车，它就是“憨豆先生”罗温·艾金森(Rowan Atkinson)的座驾。
??????这是一款蓝色车漆的双门定制版幻影，车内搭载了一款升16缸发动机，并匹配8挡自动变速箱，车辆在极限状态下能够爆发出571匹的最大马力，峰值扭矩900牛米，除了动力强劲以外这款车各方面的表现可以用“顶级”来形容。
法拉利250GTO
拍卖起价:2500万英镑(约为亿人民币)
??????法拉利250GTO是法拉利历史上最重要的车型之一，在20世纪六十年代，250GTO几乎垄断了所有汽车赛事的冠军。从1952年推出到1964年停产，250GTO只生产了36辆，而现存的仅有5辆。250GTO搭载的 Type125发动机可以说是当时最先进的发动机，该款发动机可以输出302匹马力，百公里加速只要秒。
兰博基尼Concept S
售价亿元
??????兰博基尼爱马仕(Concept S)是于2005年推出的概念车型，作为兰博基尼盖拉多的原型在当时的日内瓦车展上亮相，目前兰博基尼爱马仕目前存放于兰博基尼博物馆。
??????实际上兰博基尼Concept S并非兰博基尼与爱马仕合作生产的车型，并且作为一款概念车Concept S也未曾有任何官方报价，所以亿的报价更多的是网上误传。
??????但是即使Concept S真的是亿售价也不会让人惊讶，因为其量产车型兰博基尼盖亚多实在是太完美了。
劳斯莱斯银魅
市场估价:超过15亿元
??????世界上最贵的车第一名是劳斯莱斯银魅(Silver Ghost)，这是一款在1906年至1926年之间生产的老爷车，当时主要是供给英国皇室使用，所以产量很低只有7874辆，而现存的也不过十辆。
??????劳斯莱斯魅影搭载的是一台7036cc的六缸发动机，最大可以输出49匹马力。在1920S后，劳斯莱斯魅影的销量不断下跌，最终停产并由劳斯莱斯幻影取代。
??????时至今日，这款老爷车已经变成了极具收藏价值的车型，据估计其收藏价值已经超过了15亿元。

如果有一亿，可以买得到的豪车有宾利欧陆、兰博基尼、迈凯伦、劳斯莱斯。它们的优点是：马力足，时速快，加速都在2到4秒之间，属于超级跑车。缺点是：生活成本变高、要耗费更多的精力去维护车子。

Lamborghini Veneno（兰博基尼毒药） LP750-4，兰博基尼现在的旗舰，2717万；
Lamborghini Sesto Elemento （兰博基尼第六元素）LP570-4，一辆限量的赛道车，2000万；
Lamborghini Aventador J （兰博基尼埃文塔多 J）LP700-4，仅一辆的纪念版，1500万；
至于兰博基尼Hermes，即是爱马仕，是概念车，放兰博基尼博物馆的，不卖
网上报价两亿什么的，假的

关键看车型了，，，比如最便宜的兰博基尼盖拉多，，，基本上350万人民币就能搞到，，，一亿人民币你自己算吧，，，30台差不多，，，，如果是最贵的原厂量产兰博基尼的话就是Veneno，，，这款车价格是4200万人民币左右，，，一亿人民币只能买两台

兰博基尼。一千亿就是一亿的一千倍，也就是一千的一亿倍，写成数字就是100000000000，也就是1后面带11个0。根据查询跑车王可知，黄金版的兰博基尼Aventador(埃文塔多)超级跑车，价值高达600万美元(约合人民币3680.7万元)，所以一千亿可以买兰博基尼跑车。兰博基尼（Automobili Lamborghini S.p.A.）是一家意大利汽车生产商，是全球顶级跑车制造商及欧洲奢侈品标志之一。

一亿以上的豪车是很少的，大部分的豪车都是在几千万之间的，也有接近一亿的。

1.柯尼塞格

这是一家来自瑞典的著名跑车品牌，很多年轻人都喜欢跑车，因为非常炫酷。这款柯尼塞格的跑车在外形上非常吸引人，性能上也不错。当然，价格也是不菲的。其中一款One1的跑车售价竟然高达一亿元人民币。堪称全球十大豪车排行榜之首了。

2.迈巴赫

迈巴赫或许很多人没听过，其实它是奔驰旗下的一个超级豪华的汽车品牌。近年，迈巴赫曾推出一款豪华跑车EXElero，这款跑车从外形上看并不是非炫酷，而是更加复古。而当初只生产了一辆，被以800万美元的高价售出给南非一个商人。

3.LukanHypersort

这是一家由叙利亚制造的汽车，它的总部在黎巴嫩。这款跑车不追求量，而以质取胜。目前进推出7台限量跑车。而售价更是高达9000万人民币。其堪称全球十大豪车排行榜之一了。

相关tag:兰博基尼跑车一亿元的
本站部分资源来源于网络，如果侵犯了您的权益，请联系我们删除1354090129@qq.com

我们有个数据结构的哈夫曼编码解码的课程设计，你能帮帮我吗 ♂

我们有个数据结构的哈夫曼编码解码的课程设计，你能帮帮我吗

• 我们有个数据结构的哈夫曼编码解码的课程设计，你能帮帮我吗
• 求个哈夫曼编码的设计与实现（数据结构课程设计）拜托各位了 3Q
• 求一个<哈夫曼编码>数据结构课程设计（C语言版）
• 求一个关于二叉树的报告 内容包括：（1）在二叉链表上实现二叉树运算 （2）哈夫曼编码和译码系统

树和哈夫曼树实验报告
一．实验目的
练习树和哈夫曼树的有关操作，和各个算法程序，理解哈夫曼树的编码和译码
二．实验环境
Microsoft visual c++
三．实验问题描述
1. 问题描述：建立一棵用二叉链表方式存储的二叉树，并对其进行遍历（先序、中序和后序），打印输出遍历结果。
基本要求：从键盘接受输入先序序列，以二叉链表作为存储结构，建立二叉树（以先序来建立），并将此二叉树按照“树状形式”打印输出，然后对其进行遍历（先序、中序和后序），最后将遍历结果打印输出。在遍历算法中要求至少有一种遍历采用非递归方法。
测试数据：
ABC??DE?G??F???（其中?表示空格字符）
输出结果为：
先序：ABCDEGF
先序：CBEGDFA
先序：CGEFDBA
2. 问题描述：利用哈夫曼编码进行通信可以大大提高信道利用率，缩短信息传输时间，降低传输成本。但是，这要求在发送端通过一个编码系统对待传数据预先编码，在接受端将传来的数据进行译码（复原）。对于双工信道（即可以双向传输信息的信道），每端都需要一个完整的编/译码系统。试为这样的信息收发站写一个哈夫曼码的编/译码系统。
基本要求：(至少完成功能1-2）
一个完整的系统应具有以下功能：
I：初始化（Initialization）。从终端读入字符集大小n，以及n个字符和n个权值，建立哈夫曼树，并将它存于文件hfmTree中。
基本要求：
E：编码（Encoding）。利用已建好的哈夫曼树（如不在内存，则从文件hfmTree中读入），对文件ToBeTran中的正文进行编码，然后将结果存入文件CodeFile中。
D：译码（Decoding )。利用已建好的哈夫曼树将文件CodeFile中的代码进行译码，结果存入文件TextFile中。
P：印代码文件（Print）。将文件CodeFile以紧凑格式显示在终端上，每行50个代码。同时将此字符形式的编码文件写入文件CodePrint中。
T：印哈夫曼树（TreePrinting）。将已在内存中的哈夫曼树以直观的方式（树或凹入表形式）显示在终端上，同时将此字符形式的哈夫曼树写入文件TreePrint中。
测试数据：
设权值w=（5，29，7，8，14，23，3，11），n=8。
按照字符‘0’或‘1’确定找左孩子或右孩子，则权值对应的编码为：
5：0001，29：11，7：1110，8：1111
14：110，23：01，3：0000，11：001
用下表给出的字符集和频度的实际统计数据建立哈夫曼树，并实现以下报文的编码和译码：“THIS PROGRAM IS MY FAVORITE”。
四．实验主要程序流
实验题目一主要程序：
1．
void CreatBiTree(BitTree *bt)//用扩展先序遍历序列创建二叉树，如果是#当前树根置为空，否则申请一个新节点//
{
char ch;
ch=getchar();
if(ch==’.’)*bt=NULL;
else
{
*bt=(BitTree)malloc(sizeof(BitNode));
(*bt)-》data=ch;
CreatBiTree(&((*bt)-》LChild));
CreatBiTree(&((*bt)-》RChild));
}
}
2．void Visit(char ch)//访问根节点
{
printf(“%c “,ch);
}
3．
void PreOrder(BitTree root)
{
if (root!=NULL)
{
Visit(root -》data);
PreOrder(root -》LChild);
PreOrder(root -》RChild);
}
}
4． void InOrder(BitTree root)

{
if (root!=NULL)
{
InOrder(root -》LChild);
Visit(root -》data);
InOrder(root -》RChild);
}
}
5．int PostTreeDepth(BitTree bt) //后序遍历求二叉树的高度递归算法//
{
int hl,hr,max;
if(bt!=NULL)
{
hl=PostTreeDepth(bt-》LChild); //求左子树的深度
hr=PostTreeDepth(bt-》RChild); //求右子树的深度
max=hl》hr?hl:hr; //得到左、右子树深度较大者
return(max+1); //返回树的深度
}
else return(0); //如果是空树，则返回0
}
6．void PrintTree(BitTree Boot,int nLayer) //按竖向树状打印的二叉树 //
{
int i;
if(Boot==NULL) return;
PrintTree(Boot-》RChild,nLayer+1);
for(i=0;i《nLayer;i++)
printf(“ “);
printf(“%c “,Boot-》data);
PrintTree(Boot-》LChild,nLayer+1);
}
7．void main()
{
BitTree T;
int h;
int layer;
int treeleaf;
layer=0;
printf(“请输入二叉树中的元素(以扩展先序遍历序列输入,其中.代表空子树): “);
CreatBiTree(&T);
printf(“先序遍历序列为:“);
PreOrder(T);
printf(“ 中序遍历序列为:“);
InOrder(T);
printf(“ 后序遍历序列为:“);
PostOrder(T);
h=PostTreeDepth(T);
printf(“此二叉树的深度为:%d “,h);
printf(“此二叉树的横向显示为： “);
PrintTree(T,layer);
}
实验二主要程序流：
1．int main(){
HuffmanTree huftree;
char Choose;
while(1){
cout《《“ **********************欢迎使用哈夫曼编码/译码系统********************** “;
cout《《“*您可以进行以下操作: * “;
cout《《“*1.建立哈夫曼树 * “;
cout《《“*2.编码(源文已在文件ToBeTra中，或键盘输入) * “;
cout《《“* 3.译码(码文已在文件CodeFile中) * “;
cout《《“* 4.显示码文 * “;
cout《《“* 5.显示哈夫曼树 * “;
cout《《“* 6.退出 * “; cout《《“*********************************************************************** “;
cout《《“请选择一个操作:“;
cin》》Choose;
switch(Choose)
{
case ’1’:
huftree.CreateHuffmanTree();
break;
case ’2’:
huftree.Encoder();
break;
case ’3’:
huftree.Decoder();
break;
case ’4’:
huftree.PrintCodeFile();
break;
case ’5’:
huftree.PrintHuffmanTree();
break;
case ’6’:
cout《《“ **********************感谢使用本系统!******************* “;
system(“pause“);
return 0;
}//switch
}//while
}//main
2．// 建立哈夫曼树函数
// 函数功能：建立哈夫曼树（调用键盘建立哈夫曼树或调用从文件建立哈夫曼树的函数）
void HuffmanTree::CreateHuffmanTree()
{char Choose;
cout《《“你要从文件中读入哈夫曼树(按1)，还是从键盘输入哈夫曼树(按2)？“;
cin》》Choose;
if(Choose==’2’) { //键盘输入建立哈夫曼树 CreateHuffmanTreeFromKeyboard();
}//choose==’2’
else { //从哈夫曼树文件hfmTree.dat中读入信息并建立哈夫曼树
CreateHuffmanTreeFromFile();
}
}
3. // 从键盘建立哈夫曼树函数
// 函数功能：从键盘建立哈夫曼树
//函数参数：无
//参数返回值：无
void HuffmanTree::CreateHuffmanTreeFromKeyboard(){
int Num;
cout《《“ 请输入源码字符集个数：“;
cin》》Num;
if (Num《=1) {
cout《《“无法建立少于2个叶子结点的哈夫曼树。 “;
return;
}
LeafNum=Num;
Node=new HuffmanNode;
for(int i=0;i《Num;i++) {//读入哈夫曼树的叶子结点信息
cout《《“请输入第“《《i+1《《“个字符值“;
getchar();
Node
getchar();
cout《《“请输入该字符的权值或频度“;
cin》》Node.weight
Node.parent=-1;
Node.lchild=-1;
Node.rchild=-1;
Node.code=“0“;
}
for(int j=Num;j《2*Num-1;j++) {//循环建立哈夫曼树内部结点
int pos1,pos2;
int max1,max2;
pos2=pos1=j;
max2=max1=numeric_limits《int》::max( );
//在所有子树的根结点中，选权重最小的两个根结点，pos1最后应指向权重最小的根结点的下标
//pos2最后应指向权重第二小的根结点的下标
//max1存放当前找到的权重最小的根结点的权重
//max2存放当前找到的权重第二小的根结点的权重
for(int k=j-1;k》=0;k--) {
if (Node.parent==-1){//如果是某棵子树的根结点
if (Node.weight《max1){ //发现比当前最大值还大的权重
max2=max1;
max1=Node.weight;
pos2=pos1;
pos1=k;
}
else
if(Node.weight《max2){ //发现比当前次大值还大的次大权重
max2=Node.weight;
pos2=k;
}
}//if (Node.parent==-1)
} //for
//在下标i处新构造一个哈夫曼树的内部结点，其左、右孩子就是以上pos1、pos2所指向的结点
Node.parent=j;
Node.parent=j;
Node.lchild=pos1;
Node.rchild=pos2;
Node.parent=-1;
Node.weight;
} //for

//产生所有叶子结点中字符的编码
for (int m=0;m《Num;m++) {
//产生Node.code中
int j=m;
int j1;
while(Node
j1=Node.parent;
if(Node.lchild==j)
Node.code.insert(0,“0“);
else
Node.code.insert(0,“1“);
j=j1; }}
cout《《“哈夫曼树已成功构造完成。 “;
//把建立好的哈夫曼树写入文件hfmTree.dat
char ch;
cout《《“是否要替换原来的哈夫曼树文件(Y/N):“;
cin》》ch;
if (ch!=’y’&&ch!=’Y’) return;
ofstream fop;
fop.open(“hfmTree.dat“,ios::out|ios::binary|ios::trunc); //打开文件
if(fop.fail()) {
cout《《“ 哈夫曼树文件打开失败，无法将哈夫曼树写入hfmTree.dat文件。 “;
return;
}
fop.write((char*)&Num,sizeof(Num)); //先写入哈夫曼树的叶子结点个数
for(int n=0;n《2*Num-1;n++) { //最后写入哈夫曼树的各个结点（存储在Node中）
fop.write((char*)&Node));
flush(cout); }
fop.close(); //关闭文件
cout《《“ 哈夫曼树已成功写入hfmTree.dat文件。 “;}
4. // 从文件建立哈夫曼树函数
// 函数功能：从文件建立哈夫曼树
//函数参数：无
//参数返回值：无
void HuffmanTree::CreateHuffmanTreeFromFile(){
ifstream fip;
fip.open(“hfmTree.dat“,ios::binary|ios::in);
if(fip.fail()) {
cout《《“哈夫曼树文件hfmTree.dat打开失败，无法建立哈夫曼树。 “;
return;
}
fip.read((char*)&LeafNum,sizeof(LeafNum));
if (LeafNum《=1) {
cout《《“哈夫曼树文件中的数据有误，叶子结点个数少于2个，无法建立哈夫曼树。 “;
fip.close();
return;
}
Node=new HuffmanNode;
for(int i=0;i《2*LeafNum-1;i++)
fip.read((char*)&Node));
fip.close();
cout《《“哈夫曼树已从文件成功构造完成。 “;
}
5. // 编码函数
// 函数功能：为哈夫曼树编码
//函数参数：无
//参数返回值：无
void HuffmanTree::Encoder()
{
if(Node==NULL) { //内存没有哈夫曼树，则从哈夫曼树文件hfmTree.dat中读入信息并建立哈夫曼树
CreateHuffmanTreeFromFile();
if (LeafNum《=1) {
cout《《“内存无哈夫曼树。操作撤销。 “;
return;
}
}//if
char *SourceText; //字符串数组，用于存放源文
//让用户选择源文是从键盘输入，还是从源文文件ToBeTran.txt中读入
char Choose;
cout《《“你要从文件中读入源文(按1)，还是从键盘输入源文(按2)？“;
cin》》Choose;
if(Choose==’1’) {
ifstream fip1(“ToBeTran.txt“);
if(fip1.fail()) {
cout《《“源文文件打开失败!无法继续执行。 “;
return;
}
char ch;
int k=0;
while(fip1.get(ch)) k++; //第一次读文件只统计文件中有多少个字符，将字符数存入k
fip1.close();
SourceText=new char; //申请存放源文的字符数组空间
ifstream fip2(“ToBeTran.txt“); //第二次读源文文件，把内容写入SourceText
k=0;
while(fip2.get(ch)) SourceText=ch;
fip2.close();
SourceText=’0’;
}
else { //从键盘输入源文
string SourceBuff;
cin.ignore();
cout《《“请输入需要编码的源文(可输入任意长，按回车键结束): “;
getline(cin,SourceBuff,’ ’);
int k=0;
while(SourceBuff!=’0’)
k++;
SourceText=new char;
k=0;
while(SourceBuff!=’0’) {
SourceText;
k++;
}
SourceText=’0’;
}
cout《《“需编码的源文为：“;
cout《《SourceText《《endl;
//开始译码
ofstream fop(“CodeFile.dat“,ios::trunc); //打开码文存放文件

int k=0;
while(SourceText!=’0’) //源文串中从第一个字符开始逐个编码
{
int i;
for(i=0;i《LeafNum;i++){ //找到当前要编码的源文的字符在哈夫曼树Node中的下标
if(Node) { //将对应编码写入码文文件
fop《《Node.code;
break;
};
}
if (i》=LeafNum) {
cout《《“源文中存在不可编码的字符。无法继续执行。 “《《endl;
fop.close();
return;
}
k++; //源文串中的字符后移一个
}
fop.close();
cout《《“已完成编码，码文已写入文件CodeFile.dat中。 “;
}
6. // 译码函数
// 函数功能：对哈夫曼树进行译码
//函数参数：无
//参数返回值：无
void HuffmanTree::Decoder()
{//如果内存没有哈夫曼树，则从哈夫曼树文件hfmTree.dat中读入信息并建立哈夫曼树
if(Node==NULL)
{
CreateHuffmanTreeFromFile();
if (LeafNum《=1) {
cout《《“内存无哈夫曼树。操作撤销。 “;
return;
}
}
//将码文从文件CodeFile.dat中读入 CodeStr
ifstream fip1(“CodeFile.dat“);
if(fip1.fail()) {
cout《《“没有码文，无法译码。 “;
return;
}
char* CodeStr;
int k=0;
char ch;
while(fip1.get(ch)){
k++;
}
fip1.close();
CodeStr=new char;
ifstream fip2(“CodeFile.dat“);
k=0;
while(fip2.get(ch))
CodeStr=ch;
fip2.close();
CodeStr=’0’;
cout《《“经译码得到的源文为：“;
ofstream fop(“TextFile.dat“);
int j=LeafNum*2-1-1; //j指向哈夫曼树的根

int i=0; //码文从第一个符号开始，顺着哈夫曼树由根下行，按码文的当前符号决定下行到左孩子还是右孩子
while(CodeStr!=’0’) { //下行到哈夫曼树的叶子结点处，则译出叶子结点对应的源文字符
if(CodeStr==’0’)
j=Node.lchild;
else
j=Node.rchild;
if(Node为叶结点
cout《《Node.sourcecode; //屏幕输出译出的一个源文字符
fop《《Node.sourcecode;
j=LeafNum*2-1-1; //j再指向哈夫曼树的根
}
i++;
}
fop.close();

cout《《“ 译码成功且已存到文件TextFile.dat中。 “;
}
7. // 输出码文函数
// 函数功能：从文件中输出哈夫曼树的码文
//函数参数：无
//参数返回值：无
void HuffmanTree::PrintCodeFile()
{
char ch;
int i=1;
ifstream fip(“CodeFile.dat“);
ofstream fop(“CodePrin.dat“);
if(fip.fail())
{
cout《《“没有码文文件，无法显示码文文件内容。 “;
return;
}
while(fip.get(ch))
{cout《《ch;
fop《《ch;
if(i==50)
{
cout《《endl;
fop《《endl;
i=0;
}
i++;
}
cout《《endl;
fop《《endl;
fip.close();
fop.close();
}
8. // 输出函数
// 函数功能：从内存或文件中直接输出哈夫曼树
//函数参数：无
//参数返回值：无
void HuffmanTree::PrintHuffmanTree()
{
//如果内存没有哈夫曼树，则从哈夫曼树文件hfmTree.dat中读入信息并建立哈夫曼树
if(Node==NULL)
{
CreateHuffmanTreeFromFile();
if (LeafNum《=1) {
cout《《“内存无哈夫曼树。操作撤销。 “;
return; }}
ofstream fop(“TreePrint.dat“,ios_base::trunc);
fop.close();
PrintHuffmanTree_aoru(2*LeafNum-1-1);
return;
}

#include《string.h》 #include《stdlib.h》 #include《stdio.h》 int m,s1,s2; typedef struct { unsigned int weight; unsigned int parent,lchild,rchild; }HTNode,*HuffmanTree; typedef char *HuffmanCode; void Select(HuffmanTree HT,int n) { int i,j; for(i = 1;i 《= n;i++) if(!HT); getchar(); }

#include《stdio.h》
#include《string.h》
#include《malloc.h》
#define M 50
#define MAX 1000;
typedef struct
{
int weight;//结点权值
int parent,lchild,rchild;
}HTNODE,*HUFFMANTREE;
typedef char** HUFFMANCODE;//动态分配数组存储哈夫曼编码表
HUFFMANTREE huffmantree(int n,int weight)//构建哈夫曼树
{
int m1,m2,k;
int i,j,x1,x2;
HUFFMANTREE ht;
ht=(HUFFMANTREE)malloc((2*n)*sizeof(HTNODE));
for(i=1;i《(2*n);i++)//初始化哈夫曼树中各结点的数据，没初始值的赋值为0
{
ht.rchild=0;
if(i《=n)
ht;
else
ht.weight=0;
}
for(i=1;i《n;i++)//每一重循环从森林中选择最小的两棵树组建成一颗新树
{
m1=m2=MAX;
x1=x2=0;
for(j=1;j《(n+i);j++)
{
if((ht.parent==0))
{
m2=m1;
x2=x1;
m1=ht.weight;
x1=j;
}
else if((ht.parent==0))
{
m2=ht.weight;
x2=j;
}
}
k=n+i;
ht.parent=k;
ht.weight=m1+m2;
ht.lchild=x1;
ht.rchild=x2;
}
return ht;
}
void huffmancoding(const int n,HUFFMANCODE hc,HUFFMANTREE ht,char str)
{
int i,start,child,father;
char *cd;
hc=(HUFFMANCODE)malloc((n+1)*sizeof(char*));//分配n个字符编码的头指针
cd=(char*)malloc(n*sizeof(char));//分配求编码的工作空间
cd=’0’;//编码结束符
for(i=1;i《=n;++i)//逐个字符求哈夫曼编码
{
start=n-1;
for(child=i,father=ht.parent)/*从叶子结点到根结点求逆向编码*/
if(ht.lchild==child)
cd=’0’;
else
cd=’1’;
hc=(char*)malloc((n-start)*sizeof(char));//为i个字符编码分配空间
strcpy(hc);//从cd复制哈夫曼编码串到hc
}
free(cd);//释放工作空间
for(i=1;i《=n;++i)
{
printf(“%c的编码:“,str);
printf(“%s “,hc);
}
}
void main()
{
int i,j,k;
char str;
int weight;
printf(“请输入字符(一次性连续输入所求的字符):“);/*如:abcjhjg不要输成ab cj hig,即字符间不加空格*/
gets(str);
for(j=0;j《50;j++)
{
if(str==’0’)
break;
}
const int n=j;
for(j=n;j》0;j--)
str;
str=’0’;
for(k=0;k《n;k++)
{
printf(“请输入%c的权值:“,str);
scanf(“%d“,&weight);
}
for(k=n;k》0;k--)
weight;
weight=0;
HUFFMANCODE hc=NULL;
HUFFMANTREE ht;
ht=huffmantree(n,weight);
huffmancoding(n,hc,ht,str);
}

这是哈夫曼树
#include《iostream.h》
#include《malloc.h》
#include《string.h》
#define MAXSIZE 30
#define MAX 100
typedef struct
{
char data;
int weight;
int parent; //父结点下标
int left; //左、右孩子结点下标
int right;
}HTNode,*HuffmanTree;
typedef char * *HuffmanCode;
typedef struct
{
char data;
int weight;
}Tdata;
HuffmanTree HT; //结构体变量
HuffmanCode HC; //定义的一个变量
void SelectMinTree(HuffmanTree HT,int n,int *sl,int *s2);
void HuffmanCoding(HuffmanTree HT,Tdata *w,int n);
int main()
{
Tdata w;
int n,i;
cout《《“ 请输入元素数“《《endl;
cin》》n;
for(i=1;i《=n;i++)
{
cout《《“ 输入第 “《《i《《“ 点的数和权值:“《《endl;
cin》》w.weight;
}
cout《《“ ***********结果*************“《《endl;
HuffmanCoding(HT,w,n);
for(i=1;i《=n;i++)
cout《《w《《endl;
return 0;
}
//从ht位置，查找未加入哈夫曼树的权值最小的两个数的位置S1,S2
//S1为权值最小的位置，S2为权值第二小的位置
void SelectMinTree(HuffmanTree HT,int n,int *s1,int *s2) //选最小生成树
{
int i,min1,min2;
* s2=* s1 = 0; //初始化为0位置
min1=min2=MAX;
for(i=1;i《=n;i++) //n表示总共有几个数
{
if(HT.parent==0) //还没处理过的，以前是初始化的
if(HT.weight《min1) //如小于r1的权则设置r1为i
{
min2 = min1;
min1 = HT.weight;
*s2 = *s1;
*s1 = i;
}
else
if(HT.weight《min2) //如大于r1的权，再和r2的权比较
{
min2 = HT.weight;
*s2 = i;
}
//从i等于3开始比较
}
}
void HuffmanCoding(HuffmanTree HT,Tdata *w,int n)
{
int m,i,s1,s2,start,c,f;
HTNode *p;
char *cd;
if(n 《= 1) return; //n为结点的个数
m = 2*n -1; //总共有这么多个结点
HT = (HuffmanTree)malloc((m+1)*sizeof(HTNode));
//初始化 哈夫曼树顺序存储结构
for(p=HT+1,i=1;i《=n;i++,p++)
{
p-》data=w.data;
p-》weight=w.weight;
p-》left=0;
p-》right=0;
p-》parent=0;
}

for(;i《=m;i++,p++)
{
p-》weight=0;
p-》left=0;
p-》right=0;
p-》parent=0;
}
//构建哈夫曼树
for(i=n+1;i《=m;i++)
{
//在HT中选择parent为0且weight最小的两个结点，其序号分别为s1和s2
SelectMinTree(HT,i-1,&s1,&s2);
HT.parent = i; //把s1结点加入哈夫曼树，并设置他们的父结点位置为i
HT.parent = i; //把s2结点加入哈夫曼树，并设置他们的父结点位置为i
HT.left = s1; //设置i结点的左孩子为s1
HT.right = s2; //设置i结点的右孩子为s2
HT.weight;//设置i结点的权值为s1和s2左右孩子权值的和
}
//创建哈夫曼编码
HC = (HuffmanCode) malloc((n+1)*sizeof(char *));
cd = (char *)malloc(n*sizeof(char)); //cd数组用于保存哈夫曼编码
cd = ’0’; //设置字符串结束符
for(i=1;i《=n;i++) //分别输出n个结点的哈夫曼编码
{
start=n-1; //注意从cd数组的末尾向前加入编码
for(c=i,f=HT.parent)//从叶子结点往上走到根结点为止
if(HT.left == c)
cd = ’0’; //左0，
else
cd = ’1’; //右1
HC = (char *)malloc((n-start)*sizeof(char));
strcpy(HC
}
free(cd); //释放空间
}
二叉树运算
#include《iostream.h》
#include《malloc.h》
#define FALSE 0
#define TRUE 1
#define OK 1
#define maxsize 100
typedef int status;
typedef int elemtype;
typedef struct binode
{
elemtype data;
struct binode *lchild,*rchild;
}binode,*bitree;
status treecreated=FALSE;
int leafcount=0;
status createbitree(bitree *t);
status preordertraverse(bitree t);
int height(bitree t);
void swap(bitree *t);
void leafcounts(bitree t);
void main()
{
int choice=0;
status leave=FALSE,flag;
binode *bt;
cout《《“===========二叉树演示程序===============“《《endl;
do
{
cout《《“1：创建一个二叉树，按先序遍历结果输入，空用0表示 “《《endl;
cout《《“2：先序遍历二叉树，递归方式遍历二叉树 “《《endl;
cout《《“3：求叶子数“《《endl;
cout《《“4：计算二叉树的高度“《《endl;
cout《《“5: 树进行左右翻转“《《endl;
cout《《“0：退出“《《endl;
cout《《“-------请输入你的选择:“《《endl;
cin》》choice;
switch(choice)
{
case 1:
if(treecreated)
{
cout《《“sorry,the tree has been already created!“《《endl;
break;
};
cout《《“请输入代表树的数字：“《《endl;
flag=createbitree(&bt);
if(flag==OK)
{
cout《《“你已经建立了一棵树了！“《《endl;
treecreated=TRUE;
}
break;

case 2:
if(!treecreated)
{
cout《《“sorry,you must create a tree for further steps!“《《endl;
break;
}
cout《《“先序遍历顺序:“《《endl;
preordertraverse(bt);
cout《《endl;
break;

case 3:
if(!treecreated)
{
cout《《“sorry,you must create a tree for further steps!“《《endl;
break;
}
leafcounts(bt);
cout《《“树的叶子数:“《《leafcount《《endl;
cout《《endl;
break;

case 4:
int h;
h=height(bt);
cout《《“树的高度:“《《h《《endl;
break;

case 5:
swap(&bt);
cout《《“树已经翻转！！！“《《endl;
break;

case 0:
leave=TRUE;
break;
}
}while(!leave);
cout《《“ 谢谢 再见了！！！“《《endl;
}
//递归方法实现创建
status createbitree(bitree *t)
{
int ch=0;
cin》》ch;
if(ch==0) //输入如果是0表示是空
(*t)=NULL;
else
{
(*t)=(bitree)malloc(sizeof(binode)); //申请空间
(*t)-》data=ch; //把数据传给他
createbitree(&(*t)-》lchild); //左孩子重新进入创建函数
createbitree(&(*t)-》rchild); //右孩子重新进入创建函数
}
return OK;
}
//递归方法实现先序遍历
status preordertraverse(bitree t)
{
if(t)
{
cout《《t-》data《《“ “; //先把头结点输出
preordertraverse(t-》lchild); //然后是左结点
preordertraverse(t-》rchild); //然后是右结点
return OK;
}
else
return OK;
}
int height(bitree t)
{
int hl,hr;
if(t==NULL)
return 0;
hl=height(t-》lchild)+1; //最下面的左孩子加一
hr=height(t-》rchild)+1; //最下面的右孩子加一
return (hl》hr?hl:hr); //比较谁大就取谁
}
void swap(bitree *t) //进行左右翻转
{
bitree p;
if(*t!=NULL)
{
p=(*t)-》lchild; //p为中间变量
(*t)-》lchild=(*t)-》rchild;
(*t)-》rchild=p;
swap(&(*t)-》lchild);
swap(&(*t)-》rchild);
}
}
void leafcounts(bitree t) //求叶子数
{
if(t) //如果不为空
{
if(t-》lchild==NULL && t-》rchild==NULL)//左右孩子都为空 表明是叶子
leafcount++;
leafcounts(t-》lchild);
leafcounts(t-》rchild);
}
}

相关tag:哈夫曼编码课程设计报告
本站部分资源来源于网络，如果侵犯了您的权益，请联系我们删除1354090129@qq.com

标签：in   文件   ??   编码   for