数据结构中各种排序思路详解

排序：

Void X-Sort(ElementType A[],int N)

{
}

/*

1、 N基于正整数

2、 基于比较的排序（>=<有定义）

3、 只要讨论内部排序

4、 稳定性：任意两个相等的数据，排序前后相对位置不变

5、 X:排序算法的名称

*/

冒泡排序：

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。

冒泡排序算法的运作如下：（从后往前）

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

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

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

4. 持续每次对越来越少的元素重复上面的步骤，直到

5. 没有任何一对数字需要比较

Void Bubble_Sort (ElementType A[],int N)

{

for(p=N-1;p>=0;p--)

{

flag=0;

//一趟冒泡,p表示最后一个元素的位置（N-1）

for(i=0;i<p;i++)

{

if(A[i]>A[i++])

{

Swap(A[i],A[i+1]);

flag=1;//标志发生交换

}

}

if(flag==0) break;//全程无交换
}

}

最好情况是：顺序T=O(N)

最坏情况是：逆序T=O(N^2)

插入排序：

插入排序的思想有点像打扑克抓牌的时候，我们插入扑克牌的做法。想象一下，抓牌时，我们都是把抓到的牌按顺序放在手中。因此每抓一张新牌，我们都将其插入到已有的排好序的手牌当中，注意体会刚才的那句话。也就是说，插入排序的思想是，将新来的元素按顺序放入一个已有的有序序列当中。

 举个例子可能更容易理解一些，假设有这样一系列数字：

8 2 4 9 3 6  首先我们考虑数字2，假设后面的数字不存在（手中只有一张8，又抓来了2），那么显然2应该放在8的前面。

2 8 4 9 3 6  又抓来了一张4，现在大家都知道应该怎么办了吧？

2 4 8 9 3 6  又来了个9，没错，正好不用换顺序

2 4 8 9 3 6  同样的道理，考虑3该放的位置，显然放在2和4的中间

2 3 4 8 9 6  最后一个也是一样，最后得到从小到大的序列

2 3 4 6 8 9  完成排序

 

Void Insertion_Sort (Element Type A[],int N)

{

for (p=1;p<N;p++)

{

Tmp=A[p];//摸下一张牌，Tmp:临时位置

       for(i=p; i>0 && A[i-1]>Tmp;i--)

         A[i]=A[i-1];//向后移位，移出空位

A[i]=Tmp;//i手里的牌应该放的位置

}

}

 

希尔排序：

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

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

2. 但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位。

3. 先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量  =1(  <  …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。该方法实质上是一种分组插入方法。

选择排序：

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 

n个记录的文件的直接选择排序可经过n-1趟直接选择排序得到有序结果：

①初始状态：无序区为R[1..n]，有序区为空。

②第1趟排序

在无序区R[1..n]中选出关键字最小的记录R[k]，将它与无序区的第1个记录R[1]交换，使R[1..1]和R[2..n]分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

……

③第i趟排序

第i趟排序开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区。

思路：对比数组中前一个元素跟后一个元素的大小，如果后面的元素比前面的元素小则用一个变量k来记住他的位置，接着第二次比较，前面“后一个元素”现变成了“前一个元素”，继续跟他的“后一个元素”进行比较如果后面的元素比他要小则用变量k记住它在数组中的位置(下标)，等到循环结束的时候，我们应该找到了最小的那个数的下标了，然后进行判断，如果这个元素的下标不是第一个元素的下标，就让第一个元素跟他交换一下值，这样就找到整个数组中最小的数了。然后找到数组中第二小的数，让他跟数组中第二个元素交换一下值，以此类推。

快速排序：

快速排序（Quicksort）是对冒泡排序的一种改进。

快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

在c++中可以用函数qsort（）可以直接为数组进行排序。

用法:

void  qsort(void *base, int nelem, int width, int (*fcmp)(const void *,const void *));

参数：
1 待排序数组首地址
2 数组中待排序元素数量
3 各元素的占用空间大小
4 指向函数的指针，用于确定排序的顺序。

qsort 的使用方法：

注意：qsort,即快速排序,包含在<cstdlib>或<stdlib.h>中,
 函数有四个参数,没有返回值 下面是一个典型的写法:
 

qsort(s,n,sizeof(s[0]),cmp);

 1、 s是需要排序的数组名, 也可以理解成开始地址,  
 因为你如果只需要对数组的部分排序的话, s可以写成&s[i]的形式的
 2、参数n是参与排序的元素个数,第三个参数是单个元素的大小,
3 通常我们用sizeof()来获取大小, 因为它足够放心 绝对无毒^_^

4 cmp是一个比较函数 不过这不是系统定义好的函数 而是需要自己手动写的 也就是说 你可以把它叫做abcd或是rubbish什么
 因为是比较函数 我比较习惯用cmp
 

cmp的典型定义是　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

 int cmp(const void *a,const void *b);

假设是对int排序的话,如果是升序,那么就是如果a比b大cmp返回一个正值,小则负值,相等返回0

当然当你对具体的数组进行排序的话 cmp里面就要做具体的处理

一、对int类型数组排序

int num[100];

int cmp ( const void *a , const void *b )

{

  return *(int *)a - *(int *)b;  //升序排序

//return *(int *)b - *(int *)a; //降序排序

/*可见：参数列表是两个空指针，现在他要去指向你的数组元素。所以转型为你当前的类型，然后取值。

        升序排列时，若第一个参数指针指向的“值”大于第二个参数指针指向的“值”，则返回正；若第一个参数指针指向的“值”等于第二个参数指针指向的“值”，则返回零；若第一个参数指针指向的“值”小于第二个参数指针指向的“值”，则返回负。

        降序排列时，则刚好相反。

*/

}

qsort(s,n,sizeof(s[0]),cmp);

  

二、对char类型数组排序（同int类型）

char word[100];

int cmp( const void *a , const void *b )

{

return *(char *)a - *(char *)b;

}

qsort(word,100,sizeof(word[0]),cmp);

//附，可能 getchar();  会派上用场 

 

三、对double类型数组排序（特别要注意）

double in[100];

int cmp( const void *a , const void *b )

{

return *(double *)a > *(double *)b ? 1 : -1;

//返回值的问题，显然cmp返回的是一个整型，所以避免double返回小数而被丢失，用一个判断返回值。

}

qsort(in,100,sizeof(in[0]),cmp);

 //附：排序结果的输出，一般建议用“ %g ”格式

/* 在这里多嘴一句，"%g"格式输出 虽然书上是说系统会自动选择" %f "格式 和" %e " 格式 中长度较短的格式，并去掉无意义的0，但实际上系统如果选择了" %e "，系统会输出比“ %e " 格式更省一位的格式输出。（此结论，来自VC6.0的实际操作）*/

 

/*四、对结构体一级排序

struct In

{

double data;

int other;

}s[100]

 

//按照data的值从小到大将结构体排序,关于结构体内的排序关键数据data的类型可以很多种，参考上面的例子写

 

int cmp( const void *a ,const void *b)

{

return (*(In *)a).data > (*(In *)b).data ? 1 : -1;

//注意，这条语句在VC6.0环境下运行可能会出错，但是并不是语句错了，而是你要先Build，或者全部重建。总之语句是对的。

//或者你可以将这上面1条语句改成下面这3条语句

//struct In *aa = (In *)a;
//struct In *bb = (In *)b;
//return aa->data > bb->data ? 1 : -1;

}

qsort(s,100,sizeof(s[0]),cmp);

 

五、对结构体二级排序

struct In

{

int x;   //你可以比喻成：失败次数

int y;   //你可以比喻成：成功次数

}s[100];

 

//按照x从小到大排序，当x相等时按照y从大到小排序。 你可以想象成：失败是主要因素的一个问题，先比较 失败次数少，失败次数相同 再看 成功次数多。

 

int cmp( const void *a , const void *b )

{

struct In *c = (In *)a;

struct In *d = (In *)b;

if(c->x != d->x) return c->x - d->x;

else return d->y - c->y;

}

qsort(s,100,sizeof(s[0]),cmp);  

 

六、对字符串进行排序

struct In

{

int data;

char str[100];

}s[100];

//按照结构体中字符串str的字典顺序排序

字典排序（lexicographical order）是一种对于随机变量形成序列的排序方法。

其方法是，按照字母顺序，或者数字小大顺序，由小到大的形成序列。

 

int cmp ( const void *a , const void *b )

{

return strcmp( (*(In *)a)->str , (*(In *)b)->str );

}

qsort(s,100,sizeof(s[0]),cmp);

 */

归并排序：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

归并操作的工作原理如下：

第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置

第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置

重复步骤3直到某一指针超出序列尾

将另一序列剩下的所有元素直接复制到合并序列尾

PS：图是自己画的，图丑勿怪。哈哈~

 

2

4

6

9

15

25

 

1

5

7

13

21

30

 

1

2

4

5

6

7

9

13

15

21

25

30

 

注意：

1、 TmpA是一个临时数组，一个优秀的程序员一定会用完之后free(TmpA)

2、 因为需要申请新的空间，所以很浪费空间，一般内排序不建议用，外排序可以用

/*基数排序：

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。

第一步

以LSD为例，假设原来有一串数值如下所示：

73, 22, 93, 43, 55, 14, 28, 65, 39, 81

首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：

0

1 81

2 22

3 73 93 43

4 14

5 55 65

6

7

8 28

9 39

第二步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

81, 22, 73, 93, 43, 14, 55, 65, 28, 39

接着再进行一次分配，这次是根据十位数来分配：

0

1 14

2 22 28

3 39

4 43

5 55

6 65

7 73

8 81

9 93

第三步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

14, 22, 28, 39, 43, 55, 65, 73, 81, 93

这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。

计数排序：

计数排序是一个非基于比较的排序算法，该算法于1954年由 Harold H. Seward 提出。它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。

计数排序对输入的数据有附加的限制条件：

1、输入的线性表的元素属于有限偏序集S；

2、设输入的线性表的长度为n，|S|=k（表示集合S中元素的总数目为k），则k=O(n)。

在这两个条件下，计数排序的复杂性为O(n)。

计数排序的基本思想是对于给定的输入序列中的每一个元素x，确定该序列中值小于x的元素的个数（此处并非比较各元素的大小，而是通过对元素值的计数和计数值的累加来确定）。*/