1. //冒泡
  2. #include <iostream>
  3. using namespace std;
  4.  
  5. void bubbleSort(int* list,int index)
  6. {
  7. for(int i=index;i>;i--) //index 最大的那个索引
  8. {
  9. for(int j=;j<i;j++)
  10. {
  11. if(list[j]>list[j+])
  12. {
  13. int temp;
  14. temp=list[j];
  15. list[j]=list[j+];
  16. list[j+]=temp;
  17. }
  18. }
  19. }
  20. }
  21.  
  22. void main()
  23. {
  24. int list[]={,,,,,,,,};
  25.  
  26. for(int i=;i<;i++)
  27. cout<<list[i]<<" | ";
  28. cout<<endl;
  29.  
  30. bubbleSort(list,);//index:= 9-1
  31.  
  32. for(int i=;i<;i++)
  33. cout<<list[i]<<" | ";
  34. }
  35.  
  36. //插入排序法
  37. #include <iostream>
  38. using namespace std;
  39.  
  40. void insertSort(int* list,int index)
  41. {
  42. //在排序之前我们需要搞清一个思路,新插入一个数据的时候,排序过后的数组都是
  43. //从小到大排列好的,所以我们需要从后往前查找,直到找到比我们要插入的数字还小的
  44. //值。这个时候我们需要一个变量j作为标识
  45.  
  46. //从1开始
  47. for(int i=;i<=index;i++) //index 最大的那个索引
  48. {
  49. int insertNode=list[i];
  50. int j;
  51. for(j=i-;j>=;j--)
  52. {
  53. if(insertNode<list[j])
  54. list[j+]=list[j];
  55. else
  56. break; //因为前面的已经排序好,所以找到位置后 就可以退出了
  57. }
  58. list[j+]=insertNode;
  59. }
  60.  
  61. }
  62.  
  63. void main()
  64. {
  65. int list[]={,,,,,,,,};
  66.  
  67. for(int i=;i<;i++)
  68. cout<<list[i]<<" | ";
  69. cout<<endl;
  70.  
  71. insertSort(list,);//index:= 9-1
  72.  
  73. for(int i=;i<;i++)
  74. cout<<list[i]<<" | ";
  75. }
  76.  
  77. //选择排序法
  78. #include <iostream>
  79. using namespace std;
  80.  
  81. void selectSort(int* list,int index)
  82. {
  83. for(int i=;i<=index;i++) //index 最大的那个索引
  84. {
  85. int minValue=list[i];
  86. int minIndex=i;
  87.  
  88. for(int j=i;j<=index;j++)
  89. {
  90. if(minValue>list[j])
  91. {
  92. minValue=list[j];
  93. minIndex=j;
  94. }
  95. }
  96.  
  97. int temp;
  98. temp=list[i];
  99. list[i]=list[minIndex];
  100. list[minIndex]=temp;
  101. }
  102.  
  103. }
  104.  
  105. void main()
  106. {
  107. int list[]={,,,,,,,,};
  108.  
  109. for(int i=;i<;i++)
  110. cout<<list[i]<<" | ";
  111. cout<<endl;
  112.  
  113. selectSort(list,);//index:= 9-1
  114.  
  115. for(int i=;i<;i++)
  116. cout<<list[i]<<" | ";
  117. }
  118.  
  119. //快速排序法
  120. #include <iostream>
  121. using namespace std;
  122.  
  123. int Partition(int a[], int low, int high)
  124. {
  125. int x = a[high];//将输入数组的最后一个数作为主元,用它来对数组进行划分
  126. int i = low - ;//i是最后一个小于主元的数的下标
  127. for (int j = low; j < high; j++)//遍历下标由low到high-1的数
  128. {
  129. if (a[j] < x)//如果数小于主元的话就将i向前挪动一个位置,并且交换j和i所分别指向的数
  130. {
  131. int temp;
  132. i++;
  133. temp = a[i];
  134. a[i] = a[j];
  135. a[j] = temp;
  136. }
  137. }
  138. //经历上面的循环之后下标为从low到i(包括i)的数就均为小于x的数了,现在将主元和i+1位置上面的数进行交换
  139. a[high] = a[i + ];
  140. a[i + ] = x;
  141. return i + ;
  142. }
  143.  
  144. void QuickSort(int a[], int low, int high)
  145. {
  146. if (low < high)
  147. {
  148. int q = Partition(a, low, high);
  149. QuickSort(a, low, q - );
  150. QuickSort(a, q + , high);
  151. }
  152. }
  153.  
  154. void main(){ int arry[] = {,,,,,,,,};
  155.  
  156. for (int i = ; i < ; i++)
  157. {
  158. cout << arry[i] <<" | ";
  159. }
  160.  
  161. cout<<endl;
  162. QuickSort(arry, , );
  163. for (int i = ; i < ; i++)
  164. {
  165. cout << arry[i] <<" | ";
  166. }
  167. }

c++ 排序 冒泡 插入 选择 快速的更多相关文章

  1. 《java数据结构与算法》系列之“简单排序"-冒泡,选择,插入

    好几天又没写,因为这几天很闲,平时忙的时候自己再累都不会睡着,但是呢这没事了,照理说应该是不瞌睡了,结果还睡着了. 所以说,人很贱.也验证了一句话,没有目标的人其实最无聊.人一定要有自己的工作,这工作 ...

  2. Java数据结构和算法(三)--三大排序--冒泡、选择、插入排序

    三大排序在我们刚开始学习编程的时候就接触过,也是刚开始工作笔试会遇到的,后续也会学习希尔.快速排序,这里顺便复习一下 冒泡排序: 步骤: 1.从首位开始,比较首位和右边的索引 2.如果当前位置比右边的 ...

  3. java面试准备之基础排序——冒泡与选择排序

    选择排序:     [java]    public void select(int[] arr){            for(int i=0;i<arr.length;i++){      ...

  4. php六种基础算法:冒泡,选择,插入,快速,归并和希尔排序法

    $arr(1,43,54,62,21,66,32,78,36,76,39); 1. 冒泡排序法  *     思路分析:法如其名,就是像冒泡一样,每次从数组当中 冒一个最大的数出来.  *     比 ...

  5. 排序算法练习--JAVA(:内部排序:插入、选择、冒泡、快速排序)

    排序算法是数据结构中的经典算法知识点,也是笔试面试中经常考察的问题,平常学的不扎实笔试时候容易出洋相,回来恶补,尤其是碰到递归很可能被问到怎么用非递归实现... 内部排序: 插入排序:直接插入排序 选 ...

  6. Java四种排序:冒泡,选择,插入,二分(折半插入)

    四种排序:冒泡,选择,插入,二分(折半插入) public class Test{ // public static void main(String[] args) { // Test t=new ...

  7. python排序算法实现(冒泡、选择、插入)

    python排序算法实现(冒泡.选择.插入) python 从小到大排序 1.冒泡排序: O(n2) s=[3,4,2,5,1,9] #count = 0 for i in range(len(s)) ...

  8. python 数据结构与算法之排序(冒泡,选择,插入)

    目录 数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 数据结构与算法: 算法: 数据结构 冒泡排序法 选择排序法 插入排序法 数据结构与算法之排序(冒泡,选择,插入) 为什么学习 ...

  9. 左神算法第一节课:复杂度、排序(冒泡、选择、插入、归并)、小和问题和逆序对问题、对数器和递归(Master公式)

    第一节课 复杂度 排序(冒泡.选择.插入.归并) 小和问题和逆序对问题 对数器 递归 1.  复杂度 认识时间复杂度常数时间的操作:一个操作如果和数据量没有关系,每次都是固定时间内完成的操作,叫做常数 ...

随机推荐

  1. Java提升二:Lambda表达式与方法引用

    1.Lambda表达式 1.1.定义 lambda表达式是对于函数式接口(只含有一个抽象方法的接口)的简洁实现方式.它与匿名内部类的作用相似,但是就使用范围而言,匿名内部类更为广泛,而lambda表达 ...

  2. wx地址和腾讯地图

    如果只是要获取当前用户的经纬度和打开微信自带的地图 只需要 jsApiList: ["getLocation","openLocation"] // 先获得 w ...

  3. 013.Delphi插件之QPlugins,模块化代码示例

    这个DEMO的是一个定义了一个窗体插件接口,把其他窗口注册到这个窗体插件接口中.主程序运行起来,就遍历一下窗体插件接口,把每个窗体内嵌到对话框中 运行效果如下 主窗口代码如下 unit Frm_Mai ...

  4. 格雷码(Grey Code)生成规则

    (1) Grey码在FPGA实际应用中是实用的码,在8421BCD码累加计数器中,如果寄存器需要发生多位(两位或者以上)的跳变,会出现中间态,这样作为组合逻辑的输入是不稳妥的. 下面看两个中间态的例子 ...

  5. golang调用CertUtil获取文件md5

    func getFileMD5(fileName string) string { cmd := exec.Command("cmd", "/C", " ...

  6. Spark 资源调度 与 任务调度

    Spark 资源调度与任务调度的流程(Standalone): 启动集群后, Worker 节点会向 Master 节点汇报资源情况, Master掌握了集群资源状况. 当 Spark 提交一个 Ap ...

  7. ACM-单词接龙

    题目描述:单词接龙 问题描述:单词接龙是一个与我们经常玩的成语接龙相类似的游戏,现在我们己知一组单词,且给定一个开头的字母,要求出以这个字母开头的最长的“龙”(每个单词都最多在“龙" 中出现 ...

  8. vue的computed和method的区别

    (1)computed是响应式的,methods并非响应式. (2)computed是带缓存的 (3)computed中的成员可以只定义一个函数作为只读属性,也可以定义get/set变成可读写属性,这 ...

  9. 第十篇 Form表单

    Form表单 阅读目录(Content) Form介绍 普通的登录 使用form组件 Form那些事儿 常用字段演示 校验 使用Django Form流程 补充进阶 应用Bootstrap样式 批量添 ...

  10. 【剑指Offer】面试题22. 链表中倒数第k个节点

    题目 输入一个链表,输出该链表中倒数第k个节点.为了符合大多数人的习惯,本题从1开始计数,即链表的尾节点是倒数第1个节点.例如,一个链表有6个节点,从头节点开始,它们的值依次是1.2.3.4.5.6. ...