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 8
int 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;
else
return mid ;
}
return -1;
}
int main(void)
{
printf("%d\n", binarysearch(5));
return 0;
}2.内部排序
1. 插入排序 : 类似打扑克抓拍 , 就是将一个待排序的记录, 按关键字大小, 将记录插入到适当位置 .
#include <stdio.h>
#define LEN 5
int 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 8
int 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] |
| 49 | 38 | 65 | 97 | 76 | 13 | 27 |
( 按照算法的第三步从后面开始找，此时: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的基数排序适用于位数小的数列，如果位数多的话，使用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;
}
678
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
