排序算法 1
直观的视频http://www.cnblogs.com/wangfupeng1988/archive/2011/12/26/2302216.html
1，冒泡排序
——冒泡，每一次最大的值升到最后面，像水泡升到了水面，冒出来了，不再位于水里，不再需要比较，它已经确定了，独立了。
每次从最前面开始比较相邻的两个数，如果前面的大于后面的则交换，直到末尾最后两个，结束后末尾为最大的数。
除去已经找到的最大数，继续从最前开始，两相邻数比较，直到此次数值序列的末尾。
重复以上过程，直到最后一次只有两个数值需要比较。
//the first circle , from 0,1 to ,count-2,cout-1 //the last circle, at 0,1
对每一次的数值序列，记录其是否发生了交换，如果没有，则不需要再进行下一次的循环。
void exchange(uchar * a, uchar *b) { uchar temp; temp = *a; *a = *b; *b = temp; }
//bubble sorting int bubbleSort(int *a, int n) { int i,j; int sentinel; //to signal if exchange happen last run for(j = n - 1; j >= 1 && sentinel; j--) { sentinel = 0; for(i = 0; i<= j - 1; i++) { if(a[i] > a[i + 1]) { swap(&a[i], &a[i + 1]); sentinel = 1; } } } }
2，插入排序
--和冒泡排序逻辑伤相反，冒泡是一次找一个最大值，是个体优先，插入呢，是保证我的序列始终是整齐的，每次放入一个数值到我的序列中。
第一次整齐的序列只有1个数，把相邻的下一个数与这个数相比较，放入合适的位置
下一次，对于排好的序列，再加入下一个数，从序列末尾开始向前依次进行比较，遇到比它大得则交换，遇到比它小的，停止这一次的比较。
重复以上过程，直到最后一次插入最后一个数。
//想到初中时的推理证明题，证明无穷大的情况，从1开始证明， 然后证明n时成立，推导出无穷大时成立。
void insertSort(int *a, int n) { //1st:a[1] into a[0] //2ed:a[n - 1] into a[0]....a[n-2] int i, j; int key; for(j = 1; j <= n - 1; j++) { key = a[j]; for(i = j; i >= 1; i--) { if(a[i - 1] > key) { a[i] = a[i - 1]; } else break; } a[i] = key; } }
3，快速排序
从队列中取一个基数，例如第一个数，其余数依次和这个数比较，比它大的放右边，小的放左边。这一次循环确定了这个基数的排列位置。
对于基数左边和右边的子数列，各自取基数，同第一次循环一样把各个数放基数的两边。
重复以上操作，直到最后一次子序列只有两个数。
----快速排序的优化 http://i.youku.com/u/UMzU2MjI1NzQ0
--小型数组数据的优化。eg,待整理数组个数小于7时，直接用插入排序。
--对于基准值的选取进行优化。讲队列头，尾，中，三个数排序，取中位置的值作为基准
--将递归优化为尾递归。见归并排序。
void quickSort(uchar a[], uchar low, uchar high) { uchar i, j; uchar key; if(low >= high) return; key = a[low]; i = low; j = high; while(j>i) { while(j>i) //end at j = i; { if(a[j] < key) { a[i] = a[j]; //j is hold for key break; } j--; //positon to compare } while(i<j) //i+1 is the one to compare { i++; //positon to compare if(a[i] > key) { a[j] = a[i]; //i is now hold for key break; } } if(j > 0 ) //0-1 should be avoided j--; //positon to comparte } a[i] = key; if(i-1 >= 0) //0-1 should be avoided quickSort(a, low, i-1); quickSort(a, i+1, high); }
void quickSort3(uchar a[], uchar low, uchar high) { uchar i, j; uchar key; if(low >= high) return; key = a[low]; i = low; j = high; while(j>i) { while(j>i && a[j] >= key) { j--; //positon to compare } if(i!=j) { a[i]= a[j];//j is hold for key i++; //this step together with if condition can be omitted } while(i<j && a[i] <= key) { i++; //positon to compare } if(i!=j ) { a[j] = a[i];//i is now hold for key j--; //this step together with if condition can be omitted } } a[i] = key; if(i-1 >= 0) //0-1 should be avoided quickSort3(a, low, i-1); quickSort3(a, i+1, high); }
第二个逻辑清楚，不容易出错。
void quickSortInteration(int *a, int low, int high) { int i,j; int key; if(low >= high) return;
key = a[low]; //set a[low] as key. a[low] is empty now. i = low; //a[i] is empty, wait for date placing j = high; while(i < j) { while( key < a[j] && i < j ) { j--; } a[i] = a[j]; //a[j] is empty,waiting for date placing while( key >= a[i] && i < j ) { i++; } a[j] = a[i]; } a[i] = key; if(i > 1) { quickSortInteration(a, low, i - 1); } quickSortInteration(a, i + 1, high); } //quickSort: sort a[0]..a[n-1] into increasing order void quickSortMy(int *a, int n) { quickSortInteration(a, 0, n -1); }
//其实怎样想都可以，只要能实现就行，唯一可以用思维的地方，总要给个出路。
4，选择排序
选择排序和冒泡排序，一个从没排好的数列里找最大的，一个从没排好的数列里找最小的。选择排序就是选择最小的，一个个排。还不如叫沉泡排序呢。.下面的程序是官方的程序，虽然我本能倾向于程序该和冒泡程序类似的那种，自我开解下要是都一样就没意思了，所以选择官方这种有自己特色的选择排序。
void selectSort(int *a, int n) { //1st get a[0] from a[0]...a[n-1] //last get a[n-2] from a[n-2], a[n-1] int i,j; int min; for(i = 0; i <= n - 2; i++) { min = i; for(j = i + 1;j <= n - 1;j++) { if(a[min] > a[j]) { min = j; } } if(min != i) { swap(&a[min],&a[i]); } } }
5，归并排序
普通话不标准总觉得别扭，不过讲得还行 http://v.youku.com/v_show/id_XNjg1NTQzNTg4.html
---迭代是要用利用已经算出来的一个值去计算下一个值，从远到近，一步步接近答案。递归是要解决的规模逐渐变小。
---递归就是自己调用自己，其运作包括两个过程，先拆后合。递归需要要结束条件。
先递推：将复杂问题简单化。eg,一个数列拆成左右两个部分，各部分再拆成左右两个部分，一直拆下去，直到各部分只剩下一个值为止。再归并：在获得最简单的情况后，逐次返回，得到复杂的解。
---递归的缺点，每进行一次，就要占用一块堆栈空间，容易造成堆栈的溢出。
---尾递归。函数中递归形式的调用出现在末尾。编译器会覆盖当前用的栈空间，而不占用新的占空间。所以只要有可能，使用递归时写成尾递归的形式。
//merge: merge two sorted array void merge(int *a, int *b, int size_a, int size_b) { int i,j,k; int size_buf = size_a + size_b; int *buf = (int *)malloc(sizeof(int) * size_buf); if(buf == NULL) { printf("space alloacted fail"); return; } i = 0; j = 0; k = 0; while(i <= size_a - 1 && j <= size_b) { while(i <= size_a - 1 && a[i] <= b[j]) //store from a[i] { buf[k++] = a[i++]; } while(j <= size_b - 1 && b[j] <= a[i]) //store from b[i] { buf[k++] = b[j++]; } while(i >= size_a && j <= size_b - 1) //a passed, store b { buf[k++] = b[j++]; } while(j >= size_b && i <= size_a - 1) //b passed, store a { buf[k++] = a[i++]; } } for(i = 0; i <= size_buf - 1; i++ ) { a[i] = buf[i]; } free(buf); }
6，希尔排序
插入排序一般而言是低效的，因为一次只能将数据移动一位(//所以快速排序移动的位数最多效率最高吗），对于已经排好的序列，插入排序的效率较高。基于插入排序的特性，产生了更为高效的希尔排序。
就是再进行插入排序之前，对序列先进行一番调整，相隔远得先调一下。取一数值作为步长，将数据分成几个区间，对应值两两相比，再将步长缩小得到更小的区间，从前到后各区间对应位置的值相互比较。最后一次每个区间只剩一个数，就和插入排序一样了。迭代的过程。
void shellSort(uchar a[], uchar n) { uchar step ; uchar i,j,k; for(step=n/2;step>0;step/=2) //step is half decreased here. { for(k = 0;k <= step-1;k++) //move to the next pos { for(j = k+step;j <= n-1;j += step) //compare the values at the same pos { for(i = j;i >= step;i -= step) // i >= k + step is also ok,but confusing { if(a[i-step] > a[i]) exchange(&a[i],&a[i-step]); else break; } } } } }
7， 堆排序
//堆是挺漂亮的结构。
—— 完全二叉树两个条件，n层二叉树
1，from 1 layer to n-1 layer,with max number
2, at n layer, from left to right continuously
——二叉树成为大顶堆的两个条件：1, ki>=k2i 2,ki>=k(2i+1). 1<= i<=n/2.
——堆排序，
1，将大顶堆根节点和末尾节点交换，
2，除去当前末尾最大的数，剩下的数再调整为大顶堆，
3，重复1，2
//adding left>right for handling,not necessary.
void handleChild(uchar a[], uchar n,uchar childIndex) { uchar k; for(k = childIndex;k<=n/2 ;k*=2) { if(a[k] < a[2*k]) swap(&a[k],&a[2*k]); } } void heapSort(uchar a[], uchar n) { uchar i,j; uchar childIndex; uchar heap[i+1];for(i=0;i<=n-1;i++) { heap[i+1] = a[i]; } //repeat the progress for(j=n;j>=2;j--) { //build a big heap.2 conditions:1st,ki>=k2i,2ed,ki>=k2i+1 for(i=j/2;i>=1;i--) { childIndex = 2*i; //adjust to get right > left if(childIndex+1 <= j && heap[childIndex] < heap[childIndex+1]) { swap(&heap[childIndex],&heap[childIndex+1]); handleChild(heap,j,childIndex+1); } //compare father with right if(heap[i] < heap[childIndex]) { swap(&heap[i],&heap[childIndex]); handleChild(heap,j,childIndex); } } //place the root at the end swap(&heap[1],&heap[j]); } printf("%d\n..",count); //get the result for(i=1;i<=n;i++) { a[i-1] = heap[i]; } }
uchar count=0; void adjustNode(uchar heap[], uchar i,uchar n) { uchar j; uchar temp = heap[i]; //store node date. for(j=2*i;j<=n;j*=2) //j is left child { count++; if(j+1<=n && heap[j]<heap[j+1]) { j++; //j move to right child } if(temp>heap[j]) { break; } heap[i]=heap[j]; i = j; //current node. } heap[i] = temp; } void heapSort(uchar a[],uchar n) { uchar i; uchar heap[n+1]; //define a heap //build a tree heap[0]=0XFF; for(i=0;i<=n-1;i++) { heap[i+1]=a[i]; } //adjust node to build a heap for(i=n/2;i>=1;i--) { adjustNode(heap,i,n); } //exchange the root node with the last node.adjust the rest date to heap, for(i=n;i>=2;i--) { swap(&heap[1],&heap[i]); //the largest is placed at end. adjustNode(heap,1,i-1); } //return the dates for(i=0;i<=n-1;i++) { a[i]=heap[i+1]; } }
______test function
//scaffolding test:1,sorted;2,values consistent //sorted int sorted(int *a, int n) { int i; for(i = 0; i <= n - 2; i++) { if(a[i] > a[i + 1]) { return 0; } } return 1; } //conform: if conform, return 1;else return 0 int conform(int *a, int *b, int n) { int buf[n]; int i,j; i = n; while(i--) { buf[i] = 0; } for(j = 0; j <= n - 1;j++) { for(i = 0; i <= n - 1;i++) { if(b[j] == a[i] && buf[i] == 0) { buf[i] = 1; break; } } if(i >= n) return 0; } for(i = 0; i <= n -1; i++) { if(0 == buf[i]) return 0; } return 1; }
//memcpy,for scaffolding test. the original array need to be stored void memcpyMy( void *destination, const void *source, int n) { char *dest = destination; const char *src = source; while(n--) { *dest++ = *src++; //unitary operator calcul from right to left } } int vGenerateRandomValue(int max) { int r; //srand( (unsigned int)time(0) ); r = rand() % max + 1; // return 1 - max return r; } #define MAXN 10 int main() { int x[MAXN]; int buffer[MAXN]; int i; int n; int max = 100; for(n = 1; n <= MAXN ; n++) { printf("\n n= %d\n",n); for( i = 0; i <= n - 1; i++ ) { x[i] = vGenerateRandomValue(max) - 1; //0 - 9 printf(" %d", x[i]); } printf("\nsorted: \n"); memcpyMy(buffer,x,n*sizeof(int)); //store original dates for later test mergeSort(x,n); for( i = 0; i <= n - 1; i++ ) { printf(" %d", x[i]); } printf("\n"); #define s sorted #define c conform assert(s(x, n)); assert(c(x, buffer,n)); } return 0; }
