插入 希尔 排序 堆排序 冒泡 快速 归并

 

http://jingyixiao.com/?p=82

 

 

1，插入排序：遍历到第N个元素的时候前面的N-1个元素已经是排序好的了，那么就查找前面的N-1个元素把这第N个元素放在合适的位置，如此下去直到遍历完序列的元素为止。
它的复杂度很好算：第一个1，第二个2，排N个那就是1+2+……+N了
算法的C实现：

// 插入排序（程序摘自：http://c.chinaitlab.com/c/basic/200905/785194.html）

void InsertSort(int array[], int length){
  int i, j, key;

  　　　 for (i = 1; i < length; i++){
    key = array[i];
    // 把i之前大于array[i]的数据向后移动
    for (j = i - 1; j >= 0 && array[j] > key; j--) {
      array[j + 1] = array[j];
    }
    // 在合适位置安放当前元素
    array[j + 1] = key;
  }
}

注意点：这个没什么好注意的，搞清楚哪个位置需要移动哪个不需要就ok了～～～～
2，shell排序：对插入排序的一个改装，它每次排序把序列的元素按照某个增量分成几个子序列，对这几个子序列进行插入排序，然后不断的缩小增量扩大每个子序列的元素数量，直到增量为一的时候子序列就和原先的待排列序列一样了，此时只需要做少量的比较和移动就可以完成对序列的排序了。（是不是很帅气的思想？？ ;; -) ）
复杂度：n^(1+a) (0 < a < 1)
算法的C实现：

// shell排序（程序摘自：http://c.chinaitlab.com/c/basic/200905/785198.html）
void ShellSort(int array[], int length){
  int temp;

  　　　 // 增量从数组长度的一半开始,每次减小一倍 （他从一半，当然你可以从其他长度开始罗～～～）
    for (int increment = length / 2; increment > 0; increment /= 2)
      for (int i = increment; i < length; ++i){
	temp = array[i];
	// 对一组增量为increment的元素进行插入排序
	for (int j = i; j >= increment; j -= increment){
	  // 把i之前大于array[i]的数据向后移动
	  if (temp < array[j - increment]) {
	    array[j] = array[j - increment];
	  }
	  else{
	    break;
	  }
	}
	// 在合适位置安放当前元素
	array[j] = temp;
      }
}

注意点：这个算法精髓在这 for (int j = i; j >= increment; j -= increment)，就是用步长递减，看懂了，你就会了，没看懂，那请你静下心看吧～～～

先说到这吧，有点困了，改天接着来～～

 

 

3，该说堆排序了

堆的定义：

n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质（简称为堆性质）：

（1） ki≤K2i且ki≤K2i+1 或（2）Ki≥K2i且ki≥K2i+1（1≤i≤）

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

堆的这个性质使得可以迅速定位在一个序列之中的最小（大）的元素。

堆排序算法的过程如下：1）得到当前序列的最小（大）的元素 2）把这个元素和最后一个元素进行交换，这样当前的最小（大）的元素就放在了序列的最后，而原先的最后一个元素放到了序列的最前面 3）的交换可能会破坏堆序列的性质（注意此时的序列是除去已经放在最后面的元素），因此需要对序列进行调整，使之满足于上面堆的性质。重复上面的过程，直到序列调整完毕为止。

/*
 * FileName: HeapSort.cpp
 * Type: C++
 * Copyright: (c) 2009 Jingyi Xiao
 * Authors: Jingyi Xiao
 * Description:
 */

int MakeHeap (int * str, int i, int n){
  int tmp, child;
  for (tmp = str[i]; i*2+1 < n; i = child){ // 好好看看这里，调整一个堆的算法
    child = i * 2 + 1;
    str[child] < str[child+1] ;
    child != n-1 ? child++ : child;
    if (tmp < str[child]) str[i] = str[child];     else break;
   }
   str[i] = tmp;
 }
 int HeapSort (int * narray, int n){
   for (int i = n/2; i >= 0; i--)
      MakeHeap(narray, i, n); // 初始化有技巧，注意i=n/2

  for (int i = n-1; i >= 0; i--){  // 这里是排序的关键～～～
    swap (narray[0], narray[i]);
    MakeHeap(narray, 0, i);
  }

  // output
  for (int i = 0; i < n; i++) cout << narray[i] << ' ';
  cout << endl;
  return 0;
}

/*
 * EOF
 */

4，冒泡排序：（这个原理就不说了，直接来代码，我也不讲了，不会的google去）

/*
 * FileName: BubbleSort.cpp
 * Type: C++
 * Copyright: (c) 2009 Jingyi Xiao
 * Authors: Jingyi Xiao
 * Description:
 */

using namespace std;

int BubbleSort (int * narray, int n){
  int stop;
  for (int i = 0; i < n; i++){
    stop = 1;
    for (int j = i+1; j < n; j++)
      if (narray[i] > narray[j]) {
	swap(narray[i], narray[j]);
	stop = 0;
      }
    if (stop == 1) break;
  }

  // output
  for (int i = 0; i < n; i++) cout << narray[i] << ' ';
  cout << endl;

  return 0;
}

5,快速排序:
快速排序的算法思想： 选定一个枢纽元素(取头取尾，还是要中间，你自己定)，去好之后分割待排序序列进行分割，分割之后的序列一个部分小于枢纽元素，一个部分大于枢纽元素，再对这两个分割好的子序列进行上述的过程。（递归啦，好好看代码）

/*
 * FileName: QuikSort.cpp
 * Type: C++
 * Copyright: (c) 2009 Jingyi Xiao
 * Authors: Jingyi Xiao
 * Description:
 */

using namespace std;

int Qajust (int *str, int start, int end){
  int deadline = str[start];  // 我取这小子的头
  while (start < end){  // 大小不同，换！
    while (start < end && str[end] >= deadline) --end;
    swap (str[end], str[start]);
    while (start < end && str[start] < deadline) ++start;
    swap (str[start], str[end]);
  }

  return start;
}

int QuikSortDo(int *str, int start, int end){
  if (start < end){  // 递归了～
    int pos = Qajust(str, start, end);
    QuikSortDo(str, start, pos);
    QuikSortDo(str, pos+1, end);
  }
}

int QuikSort (int * narray, int n){
  QuikSortDo(narray, 0, n); // 这里就是测试封装了

  // output
  for (int i = 0; i < n; i++) cout << narray[i] << ' ';
  cout << endl;

  return 0;
}

6，归并排序
把待排序序列分成相同大小的两个部分，依次对这两部分进行归并排序，完毕之后再按照顺序进行合并。（递归思想重要吧？到处都是～）好了，不磨机，直接来代码。

/*
 * FileName: MergeSort.cpp
 * Type: C++
 * Copyright: (c) 2009 Jingyi Xiao
 * Note: This source file is NOT a freeware
 * Authors: Jingyi Xiao
 * Description:
 */

using namespace std;

int MergeNow(int *str, int start, int mid, int end){
  int str1[20], str2[20];
  int n1, n2;

  n1 = mid - start + 1;
  n2 = end - mid;

  for (int i = 0; i < n1; i++) str1[i] = str[start+i]; // 把元素取出来分别对待
  for (int i = 0; i < n2; i++) str2[i] = str[mid+i+1];

  str1[n1] = str2[n2] = 99999; // 设置一个很大的数
  for (int k = start, i = 0, j = 0; k <= end; k++){
    if (str1[i] <= str2[j]) str[k] = str1[i++]; // 记住，谁大我就要谁
    else str[k] = str2[j++];
  }
}

int MergeSortDo(int *str, int start, int end){
  if (start < end){ // 开始递归
    int pos = (start + end) / 2;
    MergeSortDo(str, start, pos);
    MergeSortDo(str, pos+1, end);
    MergeNow(str, start, pos, end);
  }
}

int MergeSort (int *narray, int n){
  MergeSortDo(narray, 0, n); // 这个不说了

  // output
  for (int i = 0; i < n; i++) cout << narray[i] << ' ';
  cout << endl;

  return 0;
}

好了，别的排序算法请各位自己琢磨吧，我就简单介绍了以上6种常用的排序算法，不足之处还恳请指出。当然也欢迎添加新的排序算法～