典型排序算法整理

典型排序

      本文包括直接插入排序、冒泡排序、希尔排序、堆排序和快速排序。

 

一，直接插入排序

1、基本思想
    　假设待排序的记录存放在数组R[1..n]中。初始时，R[1]自成1个有序区，无序区为R[2..n]。从i=2起直至i=n为止，依次将R[i]插入当前的有序区R[1..i-1]中，生成含n个记录的有序区。

2、第i-1趟直接插入排序：
    　通常将一个记录R[i](i=2，3，…，n-1)插入到当前的有序区，使得插入后仍保证该区间里的记录是按关键字有序的操作称第i-1趟直接插入排序。
    　排序过程的某一中间时刻，R被划分成两个子区间R[1．．i-1]（已排好序的有序区）和R[i．．n]（当前未排序的部分，可称无序区）。
    　直接插入排序的基本操作是将当前无序区的第1个记录R[i]插人到有序区R[1．．i-1]中适当的位置上，使R[1．．i]变为新的有序区。因为这种方法每次使有序区增加1个记录，通常称增量法。
    　插入排序与打扑克时整理手上的牌非常类似。摸来的第1张牌无须整理，此后每次从桌上的牌(无序区)中摸最上面的1张并插入左手的牌(有序区)中正确的位置上。为了找到这个正确的位置，须自左向右(或自右向左)将摸来的牌与左手中已有的牌逐一比较。

一趟直接插入排序方法

1．简单方法
    　首先在当前有序区R[1..i-1]中查找R[i]的正确插入位置k(1≤k≤i-1)；然后将R[k．．i-1]中的记录均后移一个位置，腾出k位置上的空间插入R[i]。
  注意：
    　若R[i]的关键字大于等于R[1．．i-1]中所有记录的关键字，则R[i]就是插入原位置。

2．改进的方法
　　一种查找比较操作和记录移动操作交替地进行的方法。
具体做法：
    　将待插入记录R[i]的关键字从右向左依次与有序区中记录R[j](j=i-1，i-2，…，1)的关键字进行比较：
    　① 若R[j]的关键字大于R[i]的关键字，则将R[j]后移一个位置；
      ②若R[j]的关键字小于或等于R[i]的关键字，则查找过程结束，j+1即为R[i]的插入位置。
    　关键字比R[i]的关键字大的记录均已后移，所以j+1的位置已经腾空，只要将R[i]直接插入此位置即可完成一趟直接插入排序。

二，冒泡排序
1、排序方法
    　将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R：凡扫描到违反本原则的轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。
（1）初始
　    R[1..n]为无序区。

（2）第一趟扫描
　    从无序区底部向上依次比较相邻的两个气泡的重量，若发现轻者在下、重者在上，则交换二者的位置。即依次比较(R[n]，R[n-1])，(R[n-1]，R[n-2])，…，(R[2]，R[1])；对于每对气泡(R[j+1]，R[j])，若R[j+1].key<R[j].key，则交换R[j+1]和R[j]的内容。
    　第一趟扫描完毕时，"最轻"的气泡就飘浮到该区间的顶部，即关键字最小的记录被放在最高位置R[1]上。

（3）第二趟扫描
　    扫描R[2..n]。扫描完毕时，"次轻"的气泡飘浮到R[2]的位置上……
    　最后，经过n-1 趟扫描可得到有序区R[1..n]
  注意：
　    第i趟扫描时，R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时，该区中最轻气泡飘浮到顶部位置R[i]上，结果是R[1..i]变为新的有序区。

三，希尔排序
    　希尔排序(Shell Sort)是插入排序的一种。因D．L．Shell于1959年提出而得名。
  基本思想：
　    先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
    　该方法实质上是一种分组插入方法。

四，堆排序
1、 堆排序定义
    　n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质(简称为堆性质)：
    　(1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ )

    　若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

五，快速排序(QuickSort)
1、算法思想
    　快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。

（1） 分治法的基本思想
    　分治法的基本思想是：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些子问题，然后将这些子问题的解组合为原问题的解。

（2）快速排序的基本思想
    　设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：
①分解：
    　在R[low..high]中任选一个记录作为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，并使左边子区间中所有记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中所有记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上，它无须参加后续的排序。
  注意：
    　划分的关键是要求出基准记录所在的位置pivotpos。划分的结果可以简单地表示为(注意pivot=R[pivotpos])：
    　R[low..pivotpos-1].keys≤R[pivotpos].key≤R[pivotpos+1..high].keys
                  其中low≤pivotpos≤high。
②求解：
   　 通过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。
③组合：
    　因为当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，"组合"步骤无须做什么，可看作是空操作。

 

// Taxis.h: interface for the CTaxis class. // // #if !defined(AFX_TAXIS_H__E03B508F_3C99_484E_9B02_125C606DE967__INCLUDED_) #define AFX_TAXIS_H__E03B508F_3C99_484E_9B02_125C606DE967__INCLUDED_ #if _MSC_VER > 1000 #pragma once #endif // _MSC_VER > 1000 /******************************************************************** created: 2009/04/28 created: 28:4:2009 9:25 file base: Taxis file ext: h author: WangFei purpose: 数据排序算法模板类，主要对常规类型排序（整型、浮点、字符），本类暂时使用了四种方式排序 冒泡、快速、Shell、堆排序 *********************************************************************/ template<typename Type> class CTaxis { public: int insert(type* buf, int n);//直接插入排列 int quick(Type *buf,int n);//快速 int bub(Type *buf, int n);//冒泡 int shell(Type *buf,int n);//Shell int heap(Type *buf,int n);//堆排序 CTaxis(); virtual ~CTaxis(); private: //交换数据 void exchange(Type *p1,Type *p2); //把数组分为二部分，前部分为都小于主元，后部分为都大于等于主元 int partition(Type *buf, int low, int high); //对分好左右区间的，再对左、右区间从新排序 void quickSort(Type *buf, int low, int high); //生成大根堆 void HeapAdjust(Type* buf,int startIndex, int len); }; //直接插入排列 template <class Type> CTaxis<Type>::CTaxis() { } template <class Type> CTaxis<Type>::~CTaxis() { } template <class Type> int CTaxis<Type>::insert(Type* buf, int n) { Type temp; int i = 0, j = 0;//j表示当前待插入的数据应该插入的位置 for (i = 1; i < n; i++) { temp = buf[i]; for (j = i; j > 0 && buf[j - 1] > temp; j--)//只有当j-1大于当前数据才能玩后移动数据 { buf[j] = buf[j - 1]; } buf[j] = temp; } } / //函数名：bub //函数功能：冒泡排序,算法思想是从数组前端开始比较相邻两元素，比较小的放置前段，最后最大在数组后面。 // 再从后面开始比较，比较小的放置前段，最后最小在数组前面。 //输入参数：Type *data---处理前数据 // int n---需要处理的数据总数 //输出参数：Type *data---处理后数据 //返回值：正常 //备注：2009.04.28 WangFei / template <class Type> int CTaxis<Type>::bub(Type *buf, int n) { if (n < 2) return -1; int j = 0,i = 0; for (i = 0; i < n; i++) { for (j = i; j < n; j++) { if (buf[i] > buf[j]) exchange(&buf[i], &buf[j]); } } return 0; } //交换指针p1,p2指向的值 template<class Type> void CTaxis<Type>::exchange(Type *p1, Type *p2) { Type temp = *p1; *p1 = *p2; *p2 = temp; } //把数组分为二部分，前部分为都小于主元，后部分为都大于等于主元 //返回的是主元所在的位置 template<class Type> int CTaxis<Type>::partition(Type *buf, int low, int high) { Type x = *(buf + high);//主元，确定队列的最后一个为主元 int i = low;//i表示比小于主元的最后一个元素大1 int j = 0; for(j = low; j < high; j++) { if(*(buf + j) < x)//把小于主元的元素都排列到前面 { exchange((buf + i), (buf + j)); i++; } } exchange((buf + high), (buf + i));//把主元叉入到都小于他的元素后面 return i;//主元所在位置 } //对分好左右区间的，再对左、右区间从新排序 template<class Type> void CTaxis<Type>::quickSort(Type *buf, int low, int high) { int pos = 0; if(low < high)//仅当区间长度大于1时才须排序 { pos = partition(buf, low, high);//对R[low..high]做划分 quickSort(buf, low, pos - 1);//对左区间递归排序 quickSort(buf, pos + 1, high);//对右区间递归排序 } } / //函数名：quick //函数功能：快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分， // 其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序， // 整个排序过程可以递归进行，以此达到整个数据变成有序序列。 //输入参数：Type *data---处理前数据 // int n---需要处理的数据总数 //输出参数：Type *data---处理后数据 //返回值：正常 //备注：2009.04.28 WangFei / template<class Type> int CTaxis<Type>::quick(Type *buf, int n) { if ( n < 2) return -1; quickSort(buf, 0 , n - 1); return 0; } / //函数名：shell //函数功能：shell排序。希尔排序(Shell sort)也称“缩小增量排序”。它的做法不是每次一个元素挨一个元素的比较。 // 而是先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录基本有序时， // 再对全体记录进行一次直接插入排序。这样大大减少了记录移动次数，提高了排序效率。 // 算法思路：先取一个正整数d1（d1＜n），把全部记录分成d1个组，所有距离为dl的倍数的记录看成是一组， // 然后在各组内进行插入排序；接着取d2（d2＜d1），重复上述分组和排序操作；直到di=1 (i＞＝1)，即所有记录成为一个组为止。 // 希尔排序对增量序列的选择没有严格规定，一般选d1约为n／2，d2为d1／2，d3为d2／2，…，di＝1。 //输入参数：Type *data---处理前数据 // int n---需要处理的数据总数 //输出参数：Type *data---处理后数据 //返回值：正常 //备注：2009.04.28 WangFei / template<class Type> int CTaxis<Type>::shell(Type* buf,int n) { if (n < 2) return -1; int i = 0, j = 0, k = 0; int step = n/2; int temp; while (step > 0) { for(i = 0; i < step; i++)//每组 { //直接插入法排列 for(j = i + step; j < n; j += step)//每组数据的标记号 { temp = buf[j]; for(k = j; k > i && buf[k - step] > temp; k -= step) { buf[k] = buf[k - step]; } buf[k] = temp; } } step /= 2;//分组步长 } return 0; } / //函数名：heap //函数功能：堆排序。 堆排序算法的基本思想是, 将数组A创建为一个最大堆, 然后交换堆的根(最大元素)和最后一个叶节点x, // 将x从堆中去掉形成新的堆A1, 然后重复以上动作,直到堆中只有一个节点. //输入参数：Type *data---处理前数据 // int n---需要处理的数据总数 //输出参数：Type *data---处理后数据 //返回值：正常 //备注：2009.04.28 WangFei / template<class Type> int CTaxis<Type>::heap(Type* buf, int n) { if (n<2) return -1; int i = 0; //将Hr[0,Lenght-1]建成大根堆 for (i= n/2 - 1; i >= 0; i--) { HeapAdjust(buf, i, n); } for (i= n-1; i > 0; i--) { //与最后一个记录交换 exchange(buf[0], buf[i]); //将H.r[0..i]重新调整为大根堆 HeapAdjust(buf, 0, i); } return 0; } //生成大根堆 template<class Type> void CTaxis<Type>::HeapAdjust(Type* buf,int startIndex, int len) { while(2*startIndex+1 < len) { int minChildrenIndex = 2*startIndex+1 ; if(2*startIndex+2 < len ) { //比较左子树和右子树，记录最大值的Index if(buf[2*startIndex+1] < buf[2*startIndex+2]) { minChildrenIndex = 2*startIndex+2; } } if(buf[startIndex] < buf[minChildrenIndex]) { //交换i与MinChildrenIndex的数据 exchange(buf[startIndex], buf[minChildrenIndex]); //堆被破坏，需要重新调整 startIndex = minChildrenIndex; } else { //比较左右孩子均大则堆未破坏，不再需要调整 break; } } return; } #endif // !defined(AFX_TAXIS_H__E03B508F_3C99_484E_9B02_125C606DE967__INCLUDED_)