排序算法汇总(图解加程序代码)

合集下载

排序算法总结-各种排序算法总结含代码【汇总】

排序算法总结|各种排序算法总结含代码

【汇总】

/2016/0901/20160901093343273.jpg" width="560" alt="排序算法总结" />

插入排序

原理

依次选择一个待排序的数据，插入到前边已排好序的序列中。

性能

时间复杂度为O(N)，空间复杂度为O(1)。算法是稳定的，比较次数和交换次数都与初始序列有关。

优化

直接插入排序每次往前插入时，是按顺序依次往前找，可在这里进行优化，往前找合适的插入位置时采用二分查找的方式，即折半插入。

折半插入排序相对直接插入排序而言：平均性能更快，时间复杂度降至O(NlogN)，排序是稳定的，但排序的比较次数与初始序列无关，总是需要foor(log(i))+1次排序比较。

使用场景

当数据基本有序时，采用插入排序可以明显减少数据交换和数据移动次数，进而提升排序效率。

代码

希尔排序

原理

插入排序的改进版，是基于插入排序的以下俩点性质而提出的改进方法：

插入排序对几乎已排好序的数据操作时，效率很高，可以达到线性排序的效率。

但插入排序在每次往前插入时只能将数据移动一位，效率比较低。

所以希尔排序的思想是：

先是取一个合适的gap

缩小间隔gap，例如去gap=ceil(gap/2)，重复上述子序列划分和排序

直到，最后gap=1时，将所有元素放在同一个序列中进行插入排序为止。

性能

开始时，gap取值较大，子序列中的元素较少，排序速度快，克服了直接插入排序的缺点;其次，gap值逐渐变小后，虽然子序列的元素逐渐变多，但大多元素已基本有序，所以继承了直接插入排序

的优点，能以近线性的速度排好序。

C语言--常见排序算法

算法分析：
1.1.3 直接插入排序
关键字比较次数和记录移动次数与记录关键字的初始排列有关。最好情况下, 排序前记录已按关键字从小到大有序, 每趟只需与前面有序记录序列的最后一个记录比较1次, 移动2次记录, 总的关键字比较次数为 n-1, 记录移动次数为 2(n-1)在平均情况下的关键字比较次数和记录移动次数约为n2/4 。
基本操作
将当前无序区的第1个记录R[i]插入到有序区R[0….i-1]中适当的位置，使R[0…i]变为新的有序区
1.1.3 直接插入排序
操作细节：
当插入第i(i≥1)个对象时, 前面的r[0], r[1], …, r[i-1]已经排好序。
用r[i]的关键字与r[i-1], r[i-2], …的关键字顺序进行比较(和顺序查找类似)，如果小于，则将r[x]向后移动(插入位置后的记录向后顺移) 找到插入位置即将r[i]插入
25 1 i k
49
2 j 49
08
0
25* 3 49 25
16 4
21
5
08
25
25*
16
21
i k 49
j 25* 25
08
25
25*
16
21
算法实例：
1.1.5 选择排序
49 2
08 0
25 1 i

C语言八大排序算法

C语⾔⼋⼤排序算法

C语⾔⼋⼤排序算法，附动图和详细代码解释！

来源：C语⾔与程序设计、⽵⾬听闲等

⼀

前⾔

如果说各种编程语⾔是程序员的招式，那么数据结构和算法就相当于程序员的内功。

想写出精炼、优秀的代码，不通过不断的锤炼，是很难做到的。

⼆

⼋⼤排序算法

排序算法作为数据结构的重要部分，系统地学习⼀下是很有必要的。

1、排序的概念

排序是计算机内经常进⾏的⼀种操作，其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。

排序分为内部排序和外部排序。

若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。

反之，若参加排序的记录数量很⼤，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。

2、排序分类

⼋⼤排序算法均属于内部排序。如果按照策略来分类，⼤致可分为：交换排序、插⼊排序、选择排序、归并排序和基数排序。如下图所⽰：

3、算法分析

1.插⼊排序

*直接插⼊排序

*希尔排序

2.选择排序

*简单选择排序

*堆排序

3.交换排序

*冒泡排序

*快速排序

4.归并排序

5.基数排序

不稳定排序：简单选择排序，快速排序，希尔排序，堆排序

稳定排序：冒泡排序，直接插⼊排序，归并排序，奇数排序

1、插⼊排序

将第⼀个和第⼆个元素排好序，然后将第3个元素插⼊到已经排好序的元素中，依次类推（插⼊排序最好的情况就是数组已经有序了）

因为插⼊排序每次只能操作⼀个元素，效率低。元素个数N，取奇数k=N/2，将下标差值为k的数分为⼀组（⼀组元素个数看总元素个数决定），在组内构成有序序列，再取k=k/2，将下标差值为k的数分为⼀组，构成有序序列，直到k=1，然后再进⾏直接插⼊排序。

各种排序算法大全37页PPT

Gap的取法有多种。 shell 提出取 gap = n/2，gap = gap/2，直到gap = 1。
6.1.5 选择排序
排序过程：
首先通过n-1次比较，从n个数中找出最小的，将它与第一个数交换—第一趟选择排序，结果最小的数被安置在第一个元素位置上再通过n-2次比较，从剩余的n-1个数中找出关键字次小的记录，将它与第二个数交换—第二趟选择排序重复上述过程，共经过n-1趟排序后，排序结束
scanf("%d",&a[i]); printf("\n"); for(i=1;i<10;i++) { k=i; 假 for(j=i+1;j<=10;j++)
if(a[j]<a[k]) k=j; 假 if(i!=k)
{ x=a[i]; a[i]=a[k]; a[k]=x;} } printf("The sorted numbers:\n"); for(i=1;i<11;i++)
08 16 21 25* 25 49
08 16 21 25* 25 49
t1
08 16 21 25* 25 49
6.1.4 希尔排序
算法分析
开始时 gap 的值较大, 子序列中的记录较少, 排序速度较快
随着排序进展, gap 值逐渐变小, 子序列中记录个数逐渐变多,由于前面大多数记录已基本有序, 所以排序速度仍然很快

十大经典排序算法

⼗⼤经典排序算法

前⾔说明

⼗⼤排序算法可以说是每个程序员都必须得掌握的了，花了⼀天的时间把代码实现且整理了⼀下，为了⽅便⼤家学习，我把它整理成⼀篇⽂章，每种算法会有简单的算法思想描述，为了⽅便⼤家理解，我还找来了动图演⽰；这还不够，我还附上了对应的优质⽂章，看完不懂你来砍我，如果不想砍我就给我来个好看。

术语解释

有些⼈可能不知道什么是稳定排序、原地排序、时间复杂度、空间复杂度，我这⾥先简单解释⼀下：

1、稳定排序：如果 a 原本在 b 的前⾯，且 a == b，排序之后 a 仍然在 b 的前⾯，则为稳定排序。

2、⾮稳定排序：如果 a 原本在 b 的前⾯，且 a == b，排序之后 a 可能不在 b 的前⾯，则为⾮稳定排序。

3、原地排序：原地排序就是指在排序过程中不申请多余的存储空间，只利⽤原来存储待排数据的存储空间进⾏⽐较和交换的数据排序。

4、⾮原地排序：需要利⽤额外的数组来辅助排序。

5、时间复杂度：⼀个算法执⾏所消耗的时间。

6、空间复杂度：运⾏完⼀个算法所需的内存⼤⼩。

⼗⼤排序

为了⽅便⼤家查找，我这⾥弄⼀个伪⽬录。

选择排序

插⼊排序

冒泡排序

⾮优化版本

优化版本

希尔排序

归并排序

递归式归并排序

⾮递归式归并排序

快速排序

堆排序

基数排序

⾮优化版本

优化版本

桶排序

基数排序

1、选择排序

过程简单描述：

⾸先，找到数组中最⼩的那个元素，其次，将它和数组的第⼀个元素交换位置(如果第⼀个元素就是最⼩元素那么它就和⾃⼰交换)。其次，在剩下的元素中找到最⼩的元素，将它与数组的第⼆个元素交换位置。如此往复，直到将整个数组排序。这种⽅法我们称之为选择排序。

【十大经典排序算法(动图演示)】必学十大经典排序算法

【十大经典排序算法（动图演示）】必学十大经典排序算法

0.1 算法分类

十种常见排序算法可以分为两大类：

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

0.2 算法复杂度

0.3 相关概念

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。不稳定：如果a原本在b的前面，而a=b，排序之后a 可能会出现在b 的后面。时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

1、冒泡排序（Bubble Sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

比较相邻的元素。如果第一个比第二个大，就交换它们两个；

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

针对所有的元素重复以上的步骤，除了最后一个；

重复步骤1~3，直到排序完成。1.2 动图演示

1.3 代码实现

1.unction bubbleSort(arr) {

2. varlen = arr.length;

算法入门--排序算法(含代码)

微信公众号：小白算法

关注可了解更多算法，并能领取免费资料。问题或建议，请公众号留言;

小白算法，简单白话算法，每个人都能看懂的算法

上一期回顾小白带你刷面试---2（图像分割）

序言

排序，顾名思义就是排列使得有序呗！！！通常意义上，我们所说的排序算法往往指的是内部排序算法，即数据记录在内存中进行排序。

排序算法大体可分为两种：

∙一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等；

∙另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。

图.排序算法对比一览表

一：冒泡排序（BubbleSort）

何为冒泡？看下下面这条鱼吐泡泡的样子，泡泡会从底端逐渐的浮上水面，由于水压的原因，会逐渐的变大，然后炸裂，这个算法的名字就是这么形象的理解的。冒泡排序名字的由来是因为越小(或越大)的元素会经由交换慢慢“浮”到数列的顶端。

图. 鱼吐泡泡

冒泡排序算法的步骤：

从小到大进行排序：

1 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置；

2 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数；

3 针对所有的元素重复以上的步骤，除了最后一个；

4 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

举例，采用冒泡排序实现对序列{ 6, 5, 3, 1, 8, 7, 2, 4 }排序的实现过程如下：

#include

// 分类 -------------- 内部比较排序

C语言奇偶排序算法详解及实例代码

奇偶排序（Odd-Even Sort）算法是一种简单的排序算法，它可以同时对数组中的奇数和偶数进行排序。这个算法的原理比较简单，它的思想类似冒泡排序，只不过比较的对象从相邻的两个数变为了相隔一个位置的两个数。

奇偶排序算法的步骤如下：

1.将数组分为两个部分，分别存放奇数和偶数。

2.在奇数部分中进行一轮冒泡排序，将较大的数往右移。

3.在偶数部分中进行一轮冒泡排序，将较小的数往左移。

4.重复执行步骤2和步骤3，直到数组完全有序。

下面我们来详细解析奇偶排序算法，并给出一个实例代码。

1. 定义一个函数 `void oddEvenSort(int arr[], int n)`，用于实现奇偶排序。

2. 在函数内部创建两个变量 `sorted` 和 `exchange`，分别表示数组是否已经完全有序和两个相邻元素是否发生交换。

3. 使用一个循环，首先将 `sorted` 和 `exchange` 初始化为

`false`。

4. 使用两个嵌套循环，外层循环控制数组两个部分的排序，内

层循环控制每个部分的冒泡排序。

5. 内层循环的初始条件为 `j = i % 2`，其中 `i` 表示当前循环的

次数。当 `i` 为偶数时，`j` 为 0，表示要对偶数部分排序；当

`i` 为奇数时，`j` 为 1，表示要对奇数部分排序。

6. 内层循环用于对数组中的一部分进行冒泡排序，如果发生交换，则将 `exchange` 设置为 `true`。冒泡排序的过程和一般的

冒泡排序算法类似。

7. 当内层循环结束后，判断 `exchange` 是否为 `false`，如果是，则说明数组已经完全有序，将 `sorted` 设置为 `true`，并退出

8种排序算法

一、插入排序(Insertion Sort)1. 基本思想：每次将一个待排序的数据元素，插入到前面已经排好序的数列中的适当位置，使数列依然有序；直到待排序数据元素全部插入完为止。2. 排序过程：【示例】：[初始关键字] [49] 38 65 97 76 13 27 49J=2(38) [38 49] 65 97 76 13 27 49J=3(65) [38 49 65] 97 76 13 27 49J=4(97) [38 49 65 97] 76 13 27 49J=5(76) [38 49 65 76 97] 13 27 49J=6(13) [13 38 49 65 76 97] 27 49J=7(27) [13 27 38 49 65 76 97] 49J=8(49) [13 27 38 49 49 65 76 97] 二、选择排序1. 基本思想：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。2. 排序过程：【示例】：初始关键字 [49 38 65 97 76 13 27 49]第一趟排序后 13 ［38 65 97 76 49 27 49]第二趟排序后 13 27 ［65 97 76 49 38 49]第三趟排序后 13 27 38 [97 76 49 65 49]第四趟排序后 13 27 38 49 [49 97 65 76]第五趟排序后 13 27 38 49 49 [97 97 76]第六趟排序后 13 27 38 49 49 76 [76 97]第七趟排序后 13 27 38 49 49 76 76 [ 97]最后排序结果 13 27 38 49 49 76 76 97三、冒泡排序(BubbleSort)1. 基本思想：两两比较待排序数据元素的大小，发现两个数据元素的次序相反时即进行交换，直到没有反序的数据元素为止。2. 排序过程：设想被排序的数组R［1..N］垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。【示例】：49 13 13 13 13 13 13 13 38 49 27 27 27 27 27 2765 38 49 38 38 38 38 3897 65 38 49 49 49 49 4976 97 65 49 49 49 49 4913 76 97 65 65 65 65 6527 27 76 97 76 76 76 7649 49 49 76 97 97 97 97 四、快速排序（Quick Sort）1. 基本思想：在当前无序区R[1..H]中任取一个数据元素作为比较的"基准"(不妨记为X)，用此基准将当前无序区划分为左右两个较小的无序区：R[1..I-1]和R[I+1..H]，且左边的无序子区中数据元素均小于等于基准元素，右边的无序子区中数据元素均大于等于基准元素，而基准X则位于最终排序的位置上，即R[1..I-1]≤X.Key≤R[I+1..H](1≤I≤H)，当R[1..I-1]和R[I+1..H]均非空时，分别对它们进行上述的划分过程，直至所有无序子区中的数据元素均已排序为止。2. 排序过程：【示例】：初始关键字 [49 38 65 97 76 13 27 49］第一次交换后［27 38 65 97 76 13 49 49］第二次交换后［27 38 49 97 76 13 65 49］ J向左扫描，位置不变，第三

五种常用的排序算法详解

排序算法是计算机科学中的一个重要分支，其主要目的是将一组无序的数据按照一定规律排列，以方便后续的处理和搜索。常用的排序算法有很多种，本文将介绍五种最常用的排序算法，包括冒泡排序、选择排序、插入排序、快速排序和归并排序。

一、冒泡排序

冒泡排序是最简单的排序算法之一，其基本思想是反复比较相邻的两个元素，如果顺序不对就交换位置，直至整个序列有序。由于该算法的操作过程如同水中的气泡不断上浮，因此称之为“冒泡排序”。

冒泡排序的时间复杂度为O(n^2)，属于较慢的排序算法，但由于其实现简单，所以在少量数据排序的场景中仍然有应用。以下是冒泡排序的Python实现代码：

```python

def bubble_sort(arr):

n = len(arr)

for i in range(n-1):

for j in range(n-i-1):

if arr[j] > arr[j+1]:

arr[j], arr[j+1] = arr[j+1], arr[j]

return arr

```

二、选择排序

选择排序也是一种基本的排序算法，其思想是每次从未排序的序列中选择最小数，然后放到已排序的序列末尾。该算法的时间复杂度同样为O(n^2)，但与冒泡排序相比，它不需要像冒泡排序一样每次交换相邻的元素，因此在数据交换次数上略有优势。

以下是选择排序的Python代码：

```python

def selection_sort(arr):

n = len(arr)

for i in range(n-1):

min_idx = i

c语言常见排序算法

常见的C语言排序算法有以下几种：

1. 冒泡排序（Bubble Sort）：比较相邻的元素，如果前一个元素大于后一个元素，则交换它们的位置，重复这个过程直到整个序列有序。

2. 插入排序（Insertion Sort）：将未排序的元素逐个插入到已排序序列中的正确位置，直到整个序列有序。

3. 选择排序（Selection Sort）：每次从未排序的元素中选择最小的元素，将其放到已排序序列的末尾，重复这个过程直到整个序列有序。

4. 快速排序（Quick Sort）：选择一个基准元素，将序列分成两部分，一部分小于等于基准元素，一部分大于基准元素，然后对两部分递归地进行快速排序。

5. 归并排序（Merge Sort）：将序列分成两部分，分别对两部分进行归并排序，然后将两个有序的子序列合并成一个有序的序列。

6. 堆排序（Heap Sort）：将序列构建成一个最大堆，然后将堆顶元素与堆末尾元素交换，重复这个过程直到整个序列有序。

7. 希尔排序（Shell Sort）：将序列按照一定的间隔分成若干个子序列，对每个子序列进行插入排序，然后逐渐减小间隔直到间隔为1，最后对整个序列进行插入排序。

8. 计数排序（Counting Sort）：统计序列中每个元素出现的次数，然后按照元素的大小顺序将它们放入一个新的序列中。

9. 基数排序（Radix Sort）：按照元素的个位、十位、百位等依次进行排序，直到所有位数都排完为止。

以上是常见的C语言排序算法，每种算法都有其特点和适用场景，选择合适的排序算法可以提高排序效率。

C语言常见排序算法.ppt

常见排序算法
1.1 常见的排序算法
冒泡排序快速排序直接插入排序希尔排序选择排序堆排序归并排序
1.1.1 冒泡排序
算法描述
设待排序记录序列中的记录个数为n 一般地，第i趟起泡排序从1到n-i+1 依次比较相邻两个记录的关键字，如果发生逆序，则交换之其结果是这n-i+1个记录中，关键字最大的记录被交换到第n-i+1的位置上，最多作n-1趟。
21 25 49 25* 16 08 25* 012345
1.1.3 直接插入排序
实用例子：
i=4
21 25 25* 49 16 08 16 0 1 2 3 4 5 temp
i=
16 21 25 25* 49 08 08
5
0 1 2 3 4 5 temp
完成
08 16 21 25 25* 49 01234 5
算法描述：
任取待排序记录序列中的某个记录(例如取第一个记录)作为基准(枢),按照该记录的关键字大小,将整个记录序列划分为左右两个子序列左侧子序列中所有记录的关键字都小于或等于基准记录的关键字右侧子序列中所有记录的关键字都大于基准记录的关键字基准记录则排在这两个子序列中间(这也是该记录最终应安放的位置)。然后分别对这两个子序列重复施行上述方法，直到所有的记录都排在相应位置上为止。基准记录也称为枢轴（或支点）记录。取序列第一个记录为枢轴记录，其关键字为Pivotkey 指针low指向序列第一个记录位置指针high指向序列最后一个记录位置

c语言常用算法

一、前言

C语言是一种高效、快速的编程语言，被广泛应用于各种领域。在C 语言中，算法是非常重要的部分，因为它们能够帮助我们解决许多实际问题。本文将介绍C语言中常用的算法。

二、排序算法

1.冒泡排序

冒泡排序是一种简单的排序算法，它通过不断交换相邻两个元素的位置来将最大的元素放到最后。具体实现如下：

```

void bubble_sort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {

for (int j = 0; j < n - i - 1; j++) {

if (arr[j] > arr[j + 1]) {

int temp = arr[j];

arr[j] = arr[j + 1];

}

```

2.选择排序

选择排序也是一种简单的排序算法，它通过不断选择最小元素并放到前面来完成排序。具体实现如下：

```

void selection_sort(int arr[], int n) {

for (int i = 0; i < n - 1; i++) {

int min_index = i;

for (int j = i + 1; j < n; j++) {

if (arr[j] < arr[min_index]) {

min_index = j;

}

int temp = arr[i];

arr[i] = arr[min_index];

}

```

3.插入排序

插入排序是一种简单的排序算法，它通过将元素逐个插入到已排好序的序列中来完成排序。具体实现如下：

十大经典排序算法详解（动图演示+代码实现）

排序算法总览

十大排序算法可以分为比较类排序以及非比较类排序。

1.比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)O(nlogn)O(nlogn)，因此也称为非线性时间比较类排序。

2.非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：

比较类排序算法

交换排序

(1) 冒泡排序

算法思想：

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来

说并没有什么太大作用。

算法步骤：

1.比较相邻的元素。如果第一个元素比第二个元素大，就交换他们两个。

常用排序算法总结(含Java代码)

} } 执行结果： 4 5 12 13 15 17 18 23 25 27 34 34 35 37 38 49 51 53 54 56 62 64 66 76 78 97 98 99 3、效率：快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快排排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。三、直接选择排序选择排序是常用内部排序的一种，常见的实现算法有直接选择排序算法和堆排序算法，选择排序的基本思想是每次从待排数据中选择第 n 小的数据放到排序列表的第 n 个位置，假如共有 N 个数据待排，那么经过 N-1 次排序后，待
一、冒泡排序冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访要排序的
数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1、原理：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。
int score[] = { 100, 99, 90, 89, 87, 75, 69, 67 }; for (int i = 0; i < score.length -1; i++){ //最多做n-1趟排序

经典排序算法汇总(代码)

————————————————————————————————作者：————————————————————————————————日期：

3 经典排序算法总结（代码）

--fly 分享

/*冒泡法.......................................................................................................................................... 4 /*快速排序 ................................................................................................................................... 5 /*插入排序 ................................................................................................................................... 6 /*希尔（shell ）排序 ............................................................................................................ 7 /*选择排序 ................................................................................................................................... 8 /*堆排序.......................................................................................................................................... 9 /*归并排序 (11)