`
wmj2003
  • 浏览: 99745 次
  • 来自: ...
文章分类
社区版块
存档分类
最新评论

递归排序的一种实现方法。

Java算法HibernateJ#数据结构 
阅读更多
  1. importjava.util.Comparator;
  3. importcom.work.qxgl.model.QxglDept;
  5. /**
  6. *@authorwangmingjie
  7. *@date2008-9-5上午10:33:59
  8. */
  9. publicclassQxglDeptCompartorimplementsComparator<QxglDept>{
  11. publicintcompare(QxglDepto1,QxglDepto2){
  12. returno1.getDeptIntroduce().compareTo(o2.getDeptIntroduce());
  14. }
  16. }
  3. importjava.util.LinkedList;
  4. importjava.util.List;
  5. importjava.util.Arrays;
  7. importcom.work.qxgl.model.QxglDept;
  9. /**
  10. *递归排序（测试成功！）
  11. *前提：知道了父节点，知道了节点所在的级别，级别内部的排序号是整数且都是唯一的。
  12. *@authorwangmingjie
  13. *@date2008-9-4下午10:05:17
  14. */
  15. publicclassSelectTreeTwo{
  17. //崔的算法：首先，增加一个属性用来组成排序的字符串的，将父结构的排序id组成字符串，规定从第1级开始排序号要定长。（最顶级为0级）
  18. //然后将组合后的排序字符串排序，递归排序就实现了。
  19. //这种算法的同一级别内排序号必须不一样才可以，否则排序将失败！
  21. publicstaticList<QxglDept>init(){
  22. List<QxglDept>l=newLinkedList<QxglDept>();
  23. //QxglDeptid，名称，父id，级别，排序号(deptIntroduce是辅助字段)
  24. QxglDepttemp=newQxglDept("0","中国",null,0,0);
  25. l.add(temp);
  26. //=====================第一级==========================
  27. temp=newQxglDept("2","山东省","0",1,2);
  28. l.add(temp);
  29. temp=newQxglDept("3","河北省","0",1,3);
  30. l.add(temp);
  31. temp=newQxglDept("1","北京市","0",1,1);
  32. l.add(temp);
  34. //0-1-11
  35. //0-10-1
  36. //0-9-1
  38. //=====================第二级==========================
  39. temp=newQxglDept("11","市辖区","1",2,11);
  40. l.add(temp);//,"0-1-11"
  41. temp=newQxglDept("12","县","1",2,12);
  42. l.add(temp);//,"0-1-12"
  43. temp=newQxglDept("21","济南市","2",2,1);
  44. l.add(temp);
  45. temp=newQxglDept("23","潍坊市","2",2,3);
  46. l.add(temp);
  47. temp=newQxglDept("22","青岛市","2",2,2);
  48. l.add(temp);
  49. temp=newQxglDept("32","唐山市","3",2,32);
  50. l.add(temp);
  51. temp=newQxglDept("31","石家庄","3",2,31);
  52. l.add(temp);
  54. //=======================第三级=================================
  55. temp=newQxglDept("112","朝阳区","11",3,112);
  56. l.add(temp);
  57. temp=newQxglDept("111","东城区","11",3,111);
  58. l.add(temp);
  59. temp=newQxglDept("113","西城区","11",3,113);
  60. l.add(temp);
  62. temp=newQxglDept("122","延庆县","12",3,122);
  63. l.add(temp);
  64. temp=newQxglDept("121","密云县","12",3,121);
  65. l.add(temp);
  67. temp=newQxglDept("213","天桥区","21",3,213);
  68. l.add(temp);
  69. temp=newQxglDept("212","市中区","21",3,212);
  70. l.add(temp);
  71. temp=newQxglDept("211","历下区","21",3,211);
  72. l.add(temp);
  74. returnl;
  75. }
  77. /**
  78. *入口方法main
  79. *@paramargs
  80. */
  81. publicstaticvoidmain(String[]args){
  82. longstart=System.currentTimeMillis();
  83. LinkedList<QxglDept>l=(LinkedList<QxglDept>)SelectTreeTwo.init();//
  84. intLEN=l.size();
  85. System.out.println("目标list大小为："+LEN);
  87. for(inti=0;i<LEN;i++){
  88. setOrderString(l,l.get(i),i);
  89. }
  90. sortList(l);
  91. printTree(l);
  92. System.out.println("总共花费"+(System.currentTimeMillis()-start)+"毫秒");
  93. }
  95. /**
  96. *根据DeptIntroduce，由小到大将list排序
  97. *
  98. *@paraml
  99. */
  100. publicstaticvoidsortList(LinkedList<QxglDept>l){
  101. //首先转换成数组
  102. QxglDept[]dest=newQxglDept[l.size()];
  103. dest=(QxglDept[])l.toArray(dest);
  104. Arrays.sort(dest,newQxglDeptCompartor());
  106. intLEN=l.size();
  107. l.clear();//必须先清空，然后按照数组的顺序增加
  108. for(inti=0;i<LEN;i++){
  109. l.add(i,dest[i]);
  110. }
  111. }
  113. /**
  114. *找到dept的父节点
  115. *
  116. *@paraml
  117. *@paramdept
  118. *@return
  119. */
  120. publicstaticintgetParentIndex(LinkedList<QxglDept>l,QxglDeptdept){
  121. intLEN=l.size();
  122. intresult=-1;
  123. StringparentId=dept.getDeptParentId();
  124. for(inti=0;i<LEN;i++){
  125. if(parentId.equals(l.get(i).getId())){
  126. result=i;
  127. break;
  128. }else{
  129. continue;
  130. }
  131. }
  132. returnresult;
  133. }
  135. /**
  136. *生成排序号的字符串
  137. *
  138. *@paraml
  139. *@paramdept
  140. *@parampos
  141. */
  142. publicstaticvoidsetOrderString(LinkedList<QxglDept>l,QxglDeptdept,
  143. intpos){
  145. if(pos==0){
  146. dept.setDeptIntroduce(dept.getDeptOrderId()+"");
  147. }else{
  148. //首先找到父节点，获取到他的DeptIntroduce,对自己当前的排序号补零；
  149. QxglDeptparentNode=l.get(getParentIndex(l,dept));
  150. dept.setDeptIntroduce(parentNode.getDeptIntroduce()+"-"
  151. +getOrderString(dept.getDeptOrderId()));
  152. }
  153. }
  155. /**
  156. *2^31=2147483648,最大为10位
  157. *
  158. *@paramorderId
  159. *@return
  160. */
  161. publicstaticStringgetOrderString(intorderId){
  162. Stringtemp="";
  163. intLEN=(orderId+"").length();
  164. for(inti=0;i<10-LEN;i++){
  165. temp=temp+"0";
  166. }
  167. temp=temp+orderId;
  168. returntemp;
  169. }
  171. publicstaticvoidprint(List<QxglDept>l){
  172. for(inti=0;i<l.size();i++){
  173. QxglDepttemp=l.get(i);
  174. System.out.println(temp.getDeptName()+"||"
  175. +temp.getDeptIntroduce());
  176. }
  177. }
  179. /**
  180. *打印树状菜单
  181. *@paraml
  182. */
  183. publicstaticvoidprintTree(List<QxglDept>l){
  184. for(inti=0;i<l.size();i++){
  185. QxglDepttemp=l.get(i);
  186. if(temp.getDeptLevel()==0)
  187. System.out.println(l.get(i).getDeptName());
  188. else{
  189. for(intj=0;j<temp.getDeptLevel()-1;j++){
  190. System.out.print("　");//补齐空格，在html中最好使用全角空格（汉字空格）。
  191. }
  192. System.out.println("┣"+l.get(i).getDeptName());
  193. }
  194. }
  195. }
  196. }

需要的pojo：

  1. publicclassQxglDeptimplementsSerializable{
  3. /**
  4. *
  5. */
  6. privatestaticfinallongserialVersionUID=-1536071285282466850L;
  8. //constructors
  9. publicQxglDept(){
  10. initialize();
  11. }
  13. /**
  14. *Constructorforprimarykey
  15. */
  16. publicQxglDept(java.lang.Stringid){
  17. this.setId(id);
  18. initialize();
  19. }
  22. /**
  23. *Constructorforrequiredfields
  24. */
  25. publicQxglDept(java.lang.Stringid,java.lang.StringdeptName,
  26. java.lang.StringdeptParentId,intdeptLevel,
  27. intdeptOrderId){
  29. this.setId(id);
  30. this.setDeptName(deptName);
  31. this.setDeptParentId(deptParentId);
  32. this.setDeptLevel(deptLevel);
  33. this.setDeptOrderId(deptOrderId);
  34. initialize();
  35. }
  38. protectedvoidinitialize(){
  39. }
  41. privateinthashCode=Integer.MIN_VALUE;
  43. //primarykey
  44. privatejava.lang.Stringid;
  46. //fields
  47. privatejava.lang.StringdeptName;
  49. privatejava.lang.StringdeptParentId;//父部门的id
  51. privateintdeptLevel;//部门级别
  53. privatejava.lang.StringdeptIdPath;//id全路径
  55. privatejava.lang.StringdeptFullname;//部门全称
  57. privateintdeptOrderId;//排序id，要能够调整
  58. //privateStringdeptCreateTime;//创建时间，由数据库自己来维护
  60. //collections
  61. privateStringdeptArea;//所在地区
  64. privateStringdeptType;//部门类别
  66. privateStringdeptLinkman;//联系人
  68. privateStringdeptLinkmanphone;//联系人电话
  70. privateStringdeptEmail;//部门电子邮箱
  72. privateStringdeptPhone;//部门电话
  74. privateStringdeptFax;//部门传真
  76. privateStringdeptAddress;//部门地址
  78. privateStringdeptPostalcode;//部门邮编
  80. privateStringdeptIntroduce;//部门简介
  84. /**
  85. *@returnthedeptAddress
  86. */
  87. publicStringgetDeptAddress(){
  88. returndeptAddress;
  89. }
  91. /**
  92. *@paramdeptAddress
  93. *thedeptAddresstoset
  94. */
  95. publicvoidsetDeptAddress(StringdeptAddress){
  96. this.deptAddress=deptAddress;
  97. }
  99. /**
  100. *@returnthedeptEmail
  101. */
  102. publicStringgetDeptEmail(){
  103. returndeptEmail;
  104. }
  106. /**
  107. *@paramdeptEmail
  108. *thedeptEmailtoset
  109. */
  110. publicvoidsetDeptEmail(StringdeptEmail){
  111. this.deptEmail=deptEmail;
  112. }
  114. /**
  115. *@returnthedeptFax
  116. */
  117. publicStringgetDeptFax(){
  118. returndeptFax;
  119. }
  121. /**
  122. *@paramdeptFax
  123. *thedeptFaxtoset
  124. */
  125. publicvoidsetDeptFax(StringdeptFax){
  126. this.deptFax=deptFax;
  127. }
  129. /**
  130. *@returnthedeptLinkman
  131. */
  132. publicStringgetDeptLinkman(){
  133. returndeptLinkman;
  134. }
  136. /**
  137. *@paramdeptLinkman
  138. *thedeptLinkmantoset
  139. */
  140. publicvoidsetDeptLinkman(StringdeptLinkman){
  141. this.deptLinkman=deptLinkman;
  142. }
  144. /**
  145. *@returnthedeptLinkmanphone
  146. */
  147. publicStringgetDeptLinkmanphone(){
  148. returndeptLinkmanphone;
  149. }
  151. /**
  152. *@paramdeptLinkmanphone
  153. *thedeptLinkmanphonetoset
  154. */
  155. publicvoidsetDeptLinkmanphone(StringdeptLinkmanphone){
  156. this.deptLinkmanphone=deptLinkmanphone;
  157. }
  159. /**
  160. *@returnthedeptPhone
  161. */
  162. publicStringgetDeptPhone(){
  163. returndeptPhone;
  164. }
  166. /**
  167. *@paramdeptPhone
  168. *thedeptPhonetoset
  169. */
  170. publicvoidsetDeptPhone(StringdeptPhone){
  171. this.deptPhone=deptPhone;
  172. }
  174. /**
  175. *@returnthedeptPostalcode
  176. */
  177. publicStringgetDeptPostalcode(){
  178. returndeptPostalcode;
  179. }
  181. /**
  182. *@paramdeptPostalcode
  183. *thedeptPostalcodetoset
  184. */
  185. publicvoidsetDeptPostalcode(StringdeptPostalcode){
  186. this.deptPostalcode=deptPostalcode;
  187. }
  189. /**
  190. *@returnthedeptType
  191. */
  192. publicStringgetDeptType(){
  193. returndeptType;
  194. }
  196. /**
  197. *@paramdeptType
  198. *thedeptTypetoset
  199. */
  200. publicvoidsetDeptType(StringdeptType){
  201. this.deptType=deptType;
  202. }
  204. /**
  205. *Returntheuniqueidentifierofthisclass
  206. *
  207. *@hibernate.idgenerator-class="uuid"column="dept_id"
  208. */
  209. publicjava.lang.StringgetId(){
  210. returnid;
  211. }
  213. /**
  214. *Settheuniqueidentifierofthisclass
  215. *
  216. *@paramid
  217. *thenewID
  218. */
  219. publicvoidsetId(java.lang.Stringid){
  220. this.id=id;
  221. this.hashCode=Integer.MIN_VALUE;
  222. }
  224. /**
  225. *Returnthevalueassociatedwiththecolumn:dept_name
  226. */
  227. publicjava.lang.StringgetDeptName(){
  228. returndeptName;
  229. }
  231. /**
  232. *Setthevaluerelatedtothecolumn:dept_name
  233. *
  234. *@paramdeptName
  235. *thedept_namevalue
  236. */
  237. publicvoidsetDeptName(java.lang.StringdeptName){
  238. this.deptName=deptName;
  239. }
  241. /**
  242. *Returnthevalueassociatedwiththecolumn:dept_parent_id
  243. */
  244. publicjava.lang.StringgetDeptParentId(){
  245. returndeptParentId;
  246. }
  248. /**
  249. *Setthevaluerelatedtothecolumn:dept_parent_id
  250. *
  251. *@paramdeptParentId
  252. *thedept_parent_idvalue
  253. */
  254. publicvoidsetDeptParentId(java.lang.StringdeptParentId){
  255. this.deptParentId=deptParentId;
  256. }
  258. /**
  259. *Returnthevalueassociatedwiththecolumn:dept_level
  260. */
  261. publicintgetDeptLevel(){
  262. returndeptLevel;
  263. }
  265. /**
  266. *Setthevaluerelatedtothecolumn:dept_level
  267. *
  268. *@paramdeptLevel
  269. *thedept_levelvalue
  270. */
  271. publicvoidsetDeptLevel(intdeptLevel){
  272. this.deptLevel=deptLevel;
  273. }
  275. /**
  276. *Returnthevalueassociatedwiththecolumn:dept_id_path
  277. */
  278. publicjava.lang.StringgetDeptIdPath(){
  279. returndeptIdPath;
  280. }
  282. /**
  283. *Setthevaluerelatedtothecolumn:dept_id_path
  284. *
  285. *@paramdeptIdPath
  286. *thedept_id_pathvalue
  287. */
  288. publicvoidsetDeptIdPath(java.lang.StringdeptIdPath){
  289. this.deptIdPath=deptIdPath;
  290. }
  292. /**
  293. *Returnthevalueassociatedwiththecolumn:dept_fullname
  294. */
  295. publicjava.lang.StringgetDeptFullname(){
  296. returndeptFullname;
  297. }
  299. /**
  300. *Setthevaluerelatedtothecolumn:dept_fullname
  301. *
  302. *@paramdeptFullname
  303. *thedept_fullnamevalue
  304. */
  305. publicvoidsetDeptFullname(java.lang.StringdeptFullname){
  306. this.deptFullname=deptFullname;
  307. }
  309. publicbooleanequals(Objectobj){
  310. if(null==obj)
  311. returnfalse;
  312. if(!(objinstanceofQxglDept))
  313. returnfalse;
  314. else{
  315. QxglDeptqxglDept=(QxglDept)obj;
  316. if(null==this.getId()||null==qxglDept.getId())
  317. returnfalse;
  318. else
  319. return(this.getId().equals(qxglDept.getId()));
  320. }
  321. }
  323. publicinthashCode(){
  324. if(Integer.MIN_VALUE==this.hashCode){
  325. if(null==this.getId())
  326. returnsuper.hashCode();
  327. else{
  328. StringhashStr=this.getClass().getName()+":"
  329. +this.getId().hashCode();
  330. this.hashCode=hashStr.hashCode();
  331. }
  332. }
  333. returnthis.hashCode;
  334. }
  336. publicStringtoString(){
  337. return"QxglDept{dept_id="+id+",dept_name="+deptName
  338. +",dept_Parent_Id="+deptParentId+",dept_leve="+deptLevel
  339. +",deptIdPath="+deptIdPath+",dept_fullname="
  340. +deptFullname+",dept_order_id="+deptOrderId+",deptArea="
  341. +deptArea+","+"dept_type="+deptType+"}";
  342. }
  344. //publicStringgetDeptCreateTime(){
  345. //returndeptCreateTime;
  346. //}
  347. //
  348. //publicvoidsetDeptCreateTime(StringdeptCreateTime){
  349. //this.deptCreateTime=deptCreateTime;
  350. //}
  352. publicintgetDeptOrderId(){
  353. returndeptOrderId;
  354. }
  356. publicvoidsetDeptOrderId(intdeptOrderId){
  357. this.deptOrderId=deptOrderId;
  358. }
  360. publicintgetHashCode(){
  361. returnhashCode;
  362. }
  364. publicvoidsetHashCode(inthashCode){
  365. this.hashCode=hashCode;
  366. }
  368. /**
  369. *@returnthedeptArea
  370. */
  371. publicStringgetDeptArea(){
  372. returndeptArea;
  373. }
  375. /**
  376. *@paramdeptArea
  377. *thedeptAreatoset
  378. */
  379. publicvoidsetDeptArea(StringdeptArea){
  380. this.deptArea=deptArea;
  381. }
  383. /**
  384. *@returnthedeptIntroduce
  385. */
  386. publicStringgetDeptIntroduce(){
  387. returndeptIntroduce;
  388. }
  390. /**
  391. *@paramdeptIntroduce
  392. *thedeptIntroducetoset
  393. */
  394. publicvoidsetDeptIntroduce(StringdeptIntroduce){
  395. this.deptIntroduce=deptIntroduce;
  396. }
  398. }

目标list大小为：19
中国
┣北京市
　┣市辖区
　　┣东城区
　　┣朝阳区
　　┣西城区
　┣县
　　┣密云县
　　┣延庆县
┣山东省
　┣济南市
　　┣历下区
　　┣市中区
　　┣天桥区
　┣青岛市
　┣潍坊市
┣河北省
　┣石家庄
　┣唐山市
总共花费15毫秒


分享到：
| 设计模式-装饰者模式
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    递归函数 递归排序法

    递归排序法是利用递归函数实现排序的一种方法。最著名的递归排序算法之一是快速排序（Quick Sort）。快速排序的核心思想是分治法：选取一个基准元素，将数组分为小于基准的元素和大于或等于基准的元素两部分，然后对...

    快速排序 --- 非递归实现

    快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出。它的基本思想是分治法，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据都要小，然后再按...

    递归方法实现快速排序

    3. **递归排序**：对基准左边的子数组和右边的子数组分别进行快速排序，这个过程通过递归调用快速排序函数来实现。如果子数组为空，递归结束；否则，重复步骤1和2。 4. **合并结果**：由于排序是就地进行的，不需要...

    堆排序递归和非递归的实现

    总的来说，这个资源提供了一个学习和实践堆排序算法的机会，涵盖了递归和非递归两种实现方式，对于理解和掌握堆排序算法有着重要的帮助。在实际应用中，根据具体场景和性能需求，可以选择适合的实现方式。

    快速排序的非递归实现

    总的来说，非递归快速排序是一种利用栈来实现的高效排序方法，它通过模拟递归过程，避免了递归调用的开销，适用于处理大规模数据。理解并熟练掌握这种算法，对于提升编程能力尤其是算法设计与分析能力非常有帮助。

    快速选择非递归与递归算法实现

    快速选择算法是基于快速排序的一种高效选择算法，用于在未排序的数据集合中找到第k小（或第k大）的元素。它由C.A.R. Hoare在1960年提出，是线性时间复杂度的算法，在平均情况下表现优秀。在本主题中，我们将深入探讨...

    快速排序的递归简洁实现

    快速排序是一种高效的排序算法，由英国计算机科学家托尼·霍尔于1960年提出。它采用分治策略来把一个序列分为较小的两个子序列，然后递归地对子序列进行排序，最终合并得到有序序列。快速排序在平均情况下的时间...

    matlab递归排序实现.zip_matlab_递归排序

    递归是一种解决问题的方法，它通过调用自身来解决更小规模的相同问题，直到达到基本情况，从而解决整个问题。在排序算法中，递归常用于实现分治策略，如快速排序、归并排序等。 归并排序（Merge Sort）是基于分治...

    c语言学习之排序 数据结构 链表 堆排序 希尔排序 快速排序 递归排序

    递归排序是一种基于递归的排序算法，时间复杂度为O(nlogn)。递归排序的原理是将数组分成两个部分，一部分是已经排好序的，一部分是未排序的。通过递归地将这两个部分排序，直到整个数组都排好序。 代码实现 下面是...

    冒泡排序和递归求和实现

    递归是一种解决问题的方法，它解决问题的各个部分，而这些部分又是相同问题的规模较小的实例。在计算求和问题中，递归通常涉及到将总和分为两个部分：一部分是第一个数字，另一部分是剩余数字的总和。递归求和的基线...

    非递归的归并排序（一种优排序）

    归并排序是一种高效的排序算法，基于分治策略。在计算机科学中，分治法是一种将大问题分解成小问题来解决的策略。归并排序利用这一策略，将一个大数组分成两个小数组，分别对它们进行排序，然后将排好序的小数组合并...

    利用递归算法实现的基数排序算法

    递归算法则是一种解决问题的方法，它解决问题的每一个子问题都是原问题的缩小版，直到子问题简单到可以直接求解。在基数排序中，递归通常用于处理每一位的排序，将大数转换为小数的过程。 基数排序的基本步骤如下：...

    归并排序的非递归实现

    归并排序是一种常用的排序算法，它的基本思想是将需要排序的数组分成两个或多个小数组，分别对每个小数组进行排序，然后将已排序的小数组合并成一个大的已排序数组。这种算法的时间复杂度为O(n log n)。 二、非递归...

    java 快速排序 折半查找的界面实现 （递归与分治法）

    3. 对基准左右两侧的子数组分别进行递归排序。 4. 当子数组只剩一个元素时，排序结束。 在Java中，快速排序可以这样实现： ```java public class QuickSort { public static void quickSort(int[] arr, int low, ...

    用队列实现非递归排序

    总的来说，用队列实现非递归排序是一种可行的方法，虽然在某些情况下效率可能不高，但其简单易懂的逻辑和无递归的特点使其在特定场景下具有一定的价值。在设计和优化排序算法时，需要根据数据特性以及对时间和空间...

    JAVA快速排序（递归实现与非递归堆栈模拟实现）

    快速排序是一种非常高效的排序算法，它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分的所有记录都比另一部分的所有记录都要小，然后分别对这两部分继续进行排序，以达到整个序列有序的目的。...

    归并排序，消除递归归并排序，快排，Java实现

    Java中，可以使用`java.util.Arrays.sort()`方法，它内部实现了高效的排序算法，对于小数组可能会使用插入排序，大数组则使用了Timsort，一种结合了归并排序和插入排序优点的混合排序算法。 以上就是关于归并排序、...

    递归归并排序算法

    归并排序算法是基于分治策略的一种高效排序方法，其时间复杂度为O(n log n)，空间复杂度为O(n)。该算法适用于大数据量的排序问题，在实际应用中有着广泛的应用场景。通过上述代码的分析，我们可以看到归并排序的具体...

    插入排序、选择排序、希尔排序、堆排序、冒泡、双向冒泡、快速排序、归并排序、递归的归并排序、基数排序

    4. 堆排序：堆排序是一种树形选择排序，通过构建最大堆或最小堆来实现排序。它的平均和最坏情况时间复杂度均为O(n log n)。 5. 冒泡排序：冒泡排序是最基础的排序算法之一，通过不断交换相邻的逆序元素，使得大元素...

    全排序算法c++递归实现

    给定的C++代码实现了全排列的一种递归方法。我们首先对代码进行逐行解读： 1. **包含头文件**：`#include &lt;iostream.h&gt;`。这里使用了较老的标准库文件，现代C++更推荐使用`#include &lt;iostream&gt;`。 2. **宏定义**...

Magicbox
Global site tag (gtag.js) - Google Analytics