排序篇

 1 void select_sort(int a[], int len)
 2 {
 3     int i,j,x,l;
 4     for (i=0; i<len; i++)
 5     {
 6         x = a[i];
 7         l = i;
 8         for (j=i; j>len; j++)
 9         {
10             if (a[j]<x)
11             {
12                 x = a[j];       //x保存每次便利搜索道德最小数
13                 l = j;          //l记录最小数的位置
14             }
15         }
16         a[l] = a[i];            //把最小元素与a[i]进行交换
17         a[l] = x;
18     }
19 }

/*堆调整函数*/
void sift(int R[],int low, int high)        //因为R[]是一颗完全二叉树，所以元素的存储必须从1开始。
{
    int i=low,j=2*i;
    int temp=R[i];
    while (j<=high)
    {
        if (j<high && R[j]<R[j+1])
            ++j;
        if (temp<R[j])
        {
            R[i]=R[j];      //将R[j]调整到双亲节点的位置上
            i=j;            //修改i与j的值，以便继续向下调整
            j=2*i;
        }
        else
            break;
    }
    R[i]=temp;              //被调整节点的值放入最终位置
}

/*堆排序函数*/
void heapSort(int R[], int n)
{
    int i;
    int temp;
    for (i=n/2; i>=1; --i)      //初始化堆
        sift(R, i, n);
    for (i=n; i>=2; --i)        //进行n-1次循环完成堆排序
    {
        /*以下三行换出了根节点中元素，将其放入最终位置*/
        temp=R[1];
        R[1]=R[i];
        R[i]=temp;
        sift(R, 1, i-1);        //对栈顶元素进行调整
    }
}

 1 #include <iostream>
 2 using namespace std;
 3 
 4 /*区间归并排序*/
 5 void Merge(int a[], int tmp[], int lPos, int rPos, int rEnd)
 6 {
 7     int i,lEnd,NumElements,tmpPos;
 8     lEnd = rPos-1;
 9     tmpPos = lPos;
10     NumElements = rEnd - lPos +1;       //数组长度
11     
12     while(lPos <= lEnd && rPos <= rEnd)
13     {
14         if (a[lPos] <= a[rEnd])         //比较两端元素
15             tmp[tmpPos++]=a[lPos++];  //把较小的之先放入tmp临时数组
16         else
17             tmp[tmpPos++]=a[rPos++];
18     }
19     while (lPos <= lEnd)                //把左端上与元素放入tmp
20         tmp[tmpPos++] = a[lPos++];
21     
22     while (rPos <= rEnd)
23         tmp[tmpPos++] = a[rPos++];
24     
25     for (i=0; i<NumElements; i++,rEnd--)
26         a[rEnd] = tmp[rEnd];            //把临时数组拷贝到原始数组
27 }
28 
29 void msort(int a[], int tmp[], int low, int high)
30 {
31     if (low >= high)        //结束条件
32         return;
33     
34     int middle = (low + high)/2;        //计算分裂点
35     msort(a, tmp, low, middle);         //对子区间[low,middle]递归做归并排序
36     msort(a, tmp, middle+1, high);      //对子区间[middle+1,high]递归做归并排序
37     Merge(a, tmp, low, middle, high);   //组合，把两个有序区合并为一个有序区
38 }
39 
40 void merge_sort(int a[], int len)
41 {
42     int *tmp = NULL;            //分配临时数组空间
43     tmp = new int[len];
44     if (tmp != NULL) {
45         msort(a, tmp, 0, len-1);//调用归并排序
46         delete []tmp;           //释放临时数组内存
47     }
48 }
49 
50 int main()
51 {
52     int a[8] = {8,6,1,3,5,2,7,4};
53     merge_sort(a, 8);
54     return 0;
55 }

 1 #include <iostream>
 2 #include <math.h>
 3 using namespace std;
 4 
 5 int find_max(int a[],int len)       //查找长度为len的数组的最大元素
 6 {
 7     int max = a[0];
 8     for (int i = 1; i<len; i++) {
 9         if (max < a[i]) {
10             max = a[i];
11         }
12     }
13     return max;
14 }
15 
16 int digit_number(int number)        //计算number有多少位
17 {
18     int digit =0;
19     do
20     {
21         number /=10;
22         digit++;
23     } while (number !=0);
24     return digit;
25 }
26 
27 int kth_digit(int number,int kth)   //返回number上第kth位的数字
28 {
29     number /= pow(10,kth);
30     return number%10;
31 }
32 
33 void radix_sort(int a[],int len)    //对长度为len的数组进行基数排序
34 {
35     int *temp[10];                  //指针数组，每一个指针表示一个箱子
36     int count[10] = {0,0,0,0,0,0,0,0,0,0};      //用于存储每个箱子装有多少元素
37     int max = find_max(a, len);
38     int maxDigit = digit_number(max);
39     int i,j,k;
40     for (i=0; i<10; i++)
41     {
42         temp[i] = new int[len];                 //使每一个箱子能装下len个int元素
43         memset(temp[i], 0, sizeof(int)*len);    //初始化为0
44     }
45     for (i = 0; i<maxDigit; i++)
46     {
47         memset(count, 0, sizeof(int)*10);       //每次装箱前把count清空
48         for (j=0; j<len; j++)
49         {
50             int xx = kth_digit(a[j], i);        //将数据安装位数放入到暂存数组中
51             temp[xx][count[xx]] = a[j];
52             count[xx]++;                        //此箱子的计数递增
53         }
54         int index = 0;
55         for (j=0; j<10; j++)                    //将数据从暂存数组中取回，放入原始数组中
56         {
57             for (k=0; k<count[j]; k++)
58             {
59                 a[index++] = temp[j][k];
60             }
61         }
62     }
63 }
64 
65 int main()
66 {
67     int a[] = {22,32,19,53,47,29};
68     radix_sort(a, 6);
69     return 0;
70 }