内部排序 & 查找

1. 查找

  1. 顺序查找 : 就是从第一个元素开始搜索, 查找内容

  2. 折半查找 : 有序表时, 可以通过与关键字的比较, 实现折半查找.

  3. 二叉排序树查找 : 所谓二叉排序树是指 , 左子树小于根, 右子树大于根, 查找过程有点类似折半查找.

顺序查找

/* line find * author : kevin * date : 2012.09.29 */#include <stdio.h>char a[] = "hello world";int indexof(char letter){int i = 0;while (a[i] != '\0') {if (a[i] == letter)return i;i++;}return -1;}int main(void){printf("%d %d\n", indexof('o'), indexof('z'));return 0;}

折半查找

/*  * half find * author : kevin * date : 2012.09.29 */#include <stdio.h>#define LEN 8int a[LEN] = {1, 2, 2, 2, 5, 6, 8, 9};int binarysearch(int number){int mid, start = 0, end = LEN - 1;while (start <= end) {mid = (start + end) / 2;if (a[mid]<number)start = mid + 1;else if (a[mid] > number)end = mid - 1;elsereturn mid ;}return -1;}int main(void){printf("%d\n", binarysearch(5));return 0;}

2.内部排序

  1. 插入排序 : 类似打扑克抓拍 , 就是将一个待排序的记录, 按关键字大小, 将记录插入到适当位置 .

 

#include <stdio.h>#define LEN 5int a[LEN] = {10, 5, 2, 4, 7};void insertion_sort(void){int i, j, key;for (j=1; j<LEN; j++) {printf("%d,%d,%d,%d,%d\n", a[0], a[1], a[2], a[3], a[4]);key = a[j];i = j - 1;/* move, find the location */while (i>=0 && a[i]>key) {a[i+1] = a[i];i--;}a[i+1] = key;}printf("%d,%d,%d,%d,%d\n", a[0], a[1], a[2], a[3], a[4]);}int main(void){insertion_sort();return 0;}

2. 冒泡排序 :  两两比较, 一次循环冒出一个泡, 注意是两两比较, 不是1个跟全部比较

#include<stdio.h>#include<stdlib.h>#include<alloc.h>void maopao_sort(int *p){    int i,j;    int temp;    for(i=10;i>=1;i--){        for(j=0;j<i-1;j++){        if(*(p+j) > *(p+j+1) ){            temp = *(p+j);            *(p+j) = *(p+j+1);            *(p+j+1) = temp;    }    }    }    for(i=0;i<10;i++)        printf("%d,",*(p+i));}int main(){    int a[10] = {3,1,5,6,2,4,9,7,10,8};    /*insert_sort(a);*/      maopao_sort(a);    getchar();}

3. 希尔排序 : 基本思想是先将待排序的数字分成若干区间分别进行插入排序, 最后再进行插入排序.

又叫 缩小增量排序，是改进的插入排序，因为插入排序与序列之前位置有很大关系，如果序列之前位置合适，那么插入时，可能移动的元素就少，而希尔排序就是将整个序列按照增量分成若干子序列，然后再子序列内进行插入排序，逐渐缩小序列增量，直至增量为1时。这个增量是提前定义的，根据公式和序列规模 该序列的项来自 9 * 4^i - 9 * 2^i + 1 和 4^i - 3 * 2^i + 1 这两个算式 。 得到的结果是 ( 1,5, 19, 41, 109 ... ) , 也可以用序列总署除 2 的 办法来确定增量，例如如果是10个数，那么增量应该为( 5, 2, 1 )

void prshl(p,n) /* int n;double p[]; */{ int k,j,i; double t; k=n/2; while (k>0) { for (j=k;j<=n-1;j++){ t=p[j];i=j-k; while((i>=0)&&(p[i]>t)) { p[i+k]=p[i];i=i-k; } p[i+k]=t; } k=k/2; } return; }

希尔排序(缩小增量法) 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序 排序过程：先取一个正整数d1<n，把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1，重复上述分组和排序操作；直至di=1，即所有记录放进一个组中排序为止

初始：d＝5 49 38 65 97 76 13 27 49* 55 04

 |---------------| 38 27 |--------------| 65 49* |--------------| 97 55 |---------------| |76 04|

一趟结果 d=2 13 27 49*55 04 49 38 65 97 76

 |--------|--------|----------| 27 04 65 |--------|-------| 49* 49 97 |--------|---------|

二趟结果 13 04 49*38 27 49 55 65 97 76   d=1

三趟结果 04 13 27 38 49*49 55 65 76 97

 

4. 归并排序

/*  * Guibing sort * author : kevin * date : 2012.09.29 */#include<stdio.h>#define LEN 8int a[LEN] = {5, 2, 4, 7, 1, 3, 2, 6};/* merge, concatenate */void merge(int start, int mid, int end){int n1 = mid - start + 1;int n2 = end - mid ;int left[n1], right[n2];int i, j, k;for (i=0; i<n1; i++) {left[i] = a[start+i];}for (j=0; j<n2; j++) {right[j] = a[mid+1+j];}i = j = 0;k = start;while (i<n1 && j<n2) {if (left[i] < right[j]) {a[k++] = left[i++];} else {a[k++] = right[j++];}}while (i < n1) {a[k++] = left[i++];}while (j < n2) {a[k++] = right[j++];}}/* divide */void sort(int start, int end){int mid;if (start < end) {mid = (end + start) / 2;printf("sort(%d - %d,%d - %d) %d %d %d %d"     "%d %d %d %d\n", start, mid,     mid+1, end, a[0], a[1], a[2],     a[3], a[4], a[5], a[6], a[7]); sort(start, mid);sort(mid+1, end);merge(start, mid, end);printf("merge(%d - %d,%d - %d) %d %d %d %d"     "%d %d %d %d\n", start, mid,     mid+1, end, a[0], a[1], a[2],     a[3], a[4], a[5], a[6], a[7]); }}int main(void){sort(0, LEN-1);return 0;}

 

5. 快速排序 ( 冒泡排序改进 )

不是 两两比较，而是两个部分两个部分比较

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

 

设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。

一趟快速排序的算法是：

　　1）设置两个变量I、J，排序开始的时候：I=0，J=N-1；

　　2）以第一个数组元素作为关键数据，赋值给key，即 key=A[0]；

　　3）从J开始向前搜索，即由后开始向前搜索（J=J-1即J--），找到第一个小于key的值A[j]，A[j]与A[i]交换；

　　4）从I开始向后搜索，即由前开始向后搜索（I=I+1即I++），找到第一个大于key的A[i]，A[i]与A[j]交换；

　　5）重复第3、4、5步，直到 I=J； (3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。找到并交换的时候i， j指针位置不变。另外当i=j这过程一定正好是i+或j-完成的最后令循环结束。）

示例：待排序的数组A的值分别是：（初始关键数据：key=49） 注意关键key永远不变，永远是和key进行比较，无论在什么位置，最后的目的就是把key放在中间，小的放前面大的放后面。

　　A[0]A[1]A[2]A[3]A[4]A[5]A[6]49386597761327　进行第一次交换后：27 38 65 97 76 13 49

　　( 按照算法的第三步从后面开始找，此时:J=6）

　　进行第二次交换后：27 38 49 97 76 13 65

　　( 按照算法的第四步从前面开始找>key的值，65>49,两者交换，此时：I=2 )

　　进行第三次交换后：27 38 13 97 76 49 65

　　( 按照算法的第五步将又一次执行算法的第三步从后开始找

　　进行第四次交换后：27 38 13 49 76 97 65

　　( 按照算法的第四步从前面开始找大于key的值，97>49，两者交换，此时：I=3,J=5 )

　　此时再执行第三步的时候就发现I=J=3，从而结束一趟快速排序，那么经过一趟快速排序之后的结果是：27 38 13 49 76 97 65，即所有大于key49的数全部在49的后面，所有小于key（49）的数全部在key（49）的前面。

/*n就是需要排序的数组，left和right是你需要排序的左界和右界，如果要排序上面那个数组，那么left和right分别是0和9*/void quicksort(int n[], int left,int right){int dp;if (left<right) {/*这就是下面要讲到的函数，按照上面所说的，就是把所有小于53的数放到它的左边，大的放在右边，然后返回53在整理过的数组中的位置。*/dp=partition(n,left,right);quicksort(n,left,dp-1);quicksort(n,dp+1,right); //这两个就是递归调用，分别整理53左边的数组和右边的数组}}/*  * 我们上面提到先定位第一个数，然后整理这个数组，把比这个数小的放到它的左边，大的放右边，然后 * 返回这中间值的位置，下面这函数就是做这个的。 */int partition(int n[],int left,int right){int lo,hi,pivot,t;pivot=n[left];lo=left-1;hi=right+1;while(lo+1!=hi) {if(n[lo+1]<=pivot)lo++;else if(n[hi-1]>pivot)hi--;else {t=n[lo+1];n[++lo]=n[hi-1];n[--hi]=t;}}n[left]=n[lo];n[lo]=pivot;return lo;}

 

6. 选择排序

每一次，找出来一个最小的，数组下标要增加，第1趟在 N 个数字中找到最小的，第2趟就是 N-1 数字中找到最小的。。。。

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个的新无序区。

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

初始关键字 [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 [76 97 65 49 ]

　　第五趟排序后 13 27 38 49 49 [97 65 76]

　　第六趟排序后 13 27 38 49 49 65 [97 76]

　　第七趟排序后 13 27 38 49 49 65 76 [97]

　　最后排序结果 13 27 38 49 49 65 76 97

int main(void) 　　{ 　　int a[10],i,j,tmp,b; 　　　　for(i=0;i<10;i++) 　　a[i]=rand()%100; 　　for(i=0;i<10;i++) 　　printf("%3d",a[i]); 　　printf("\n"); 　　for(i=0;i<9;i++){ 　　tmp=i; 　　for(j=i+1;j<10;j++) 　　if(a[tmp]>a[j]) 　　tmp=j; 　　if(i!=tmp){ 　　b=a[tmp]; 　　a[tmp]=a[i]; 　　a[i]=b; 　　} 　　} 　　for(i=0;i<10;i++) 　　printf("%3d",a[i]); 　　printf("\n"); 　　return 0; 　　}

 

7 堆排序

堆排序是树形选择排序，是需要利用树结构。堆是需要满足一定的条件。

“堆”定义

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

　　(1)ki<=k(2i）且ki<=k(2i+1)(1≤i≤ n），当然，这是小根堆，大根堆则换成>=号。//k(i）相当于二叉树的非叶结点，K(2i）则是左孩子，k(2i+1）是右孩子

　　若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：

总之，麻烦，用时再查baidu吧

 

8 基数排序

基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

　　以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

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

实现方法 

　　LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。

最高位优先(Most Significant Digit first)法，简称MSD法：先按k1排序分组，同一组中记录，关键码k1相等，再对各组按k2排序分成子组，之后，对后面的关键码继续这样的排序分组，直到按最次位关键码kd对各子组排序后。再将各组连接起来，便得到一个有序序列。

　　最低位优先(Least Significant Digit first)法，简称LSD法：先从kd开始排序，再对kd-1进行排序，依次重复，直到对k1排序后便得到一个有序序列。

实现原理

     基数排序的发明可以追溯到1887年赫尔曼·何乐礼在打孔卡片制表机(Tabulation Machine)上的贡献。它是这样实现的：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

　　基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

#include <stdio.h> 　　#include <stdlib.h> 　　int main(){ 　　int data[10]={73,22,93,43,55,14,28,65,39,81}; 　　int temp[10][10]={0};  /* 基数排序算法 */int order[10]={0}; 　　int i,j,k,n,lsd; 　　k=0;n=1; 　　printf("\n排序前: "); 　　for (i=0;i<10;i++) printf("%d ",data[i]); 　　putchar('\n'); 　　while (n<=10){ 　　for (i=0;i<10;i++){ 　　lsd=((data[i]/n)%10); 　　temp[lsd][order[lsd]]=data[i]; 　　order[lsd]++; 　　} 　　printf("\n重新排列: "); 　　for (i=0;i<10;i++){ 　　if(order[i]!=0) 　　for (j=0;j<order[i];j++){ 　　data[k]=temp[i][j]; 　　printf("%d ",data[k]); 　　k++; 　　} 　　order[i]=0; 　　} 　　n*=10; 　　k=0; 　　} 　　putchar('\n'); 　　printf("\n排序后: "); 　　for (i=0;i<10;i++) printf("%d ",data[i]); 　　return 0; 　　}