数据结构 排序算法_73731341

之前每次牵涉到排序都是冒泡排序，别的排序基本很少有，因为最开始是写app的，而且大部分API 都提供的有排序函数，后来就是看一些底层，和一些面试感觉有必要再总结一下

交换数据，指针实现

void swiss(int *x,int *y){
    int temp = *x;
    *x = *y;
    *y = temp;
}
1
2
3
4
5

最简单的冒泡排序

void test_maoPao(){
    int arr[BUFFER_SIZE] ={8,14,2,3,56,43,23,12,67,4,6,13,10,9,11};
    for (int i=0; i<BUFFER_SIZE; i++) {
        for (int j=i; j<BUFFER_SIZE; j++) {
            if (arr[i]<arr[j]) {
                swiss(&arr[i], &arr[j]);
            }
        }
    }
    for (int i=0;i<BUFFER_SIZE; i++) {
        printf("%d \t",arr[i]);
        if ((i+1)%5==0) {
            printf("\n");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

快速排序 参考文章

//快速排序 
void test_quicksort(int left,int right){

    int i,j,t,temp;
    if (left>right) {
        return;
    }
    //基准数
    temp = oriArr[left];

    i = left;
    j = right;
    while (i!=j) {
        //寻找右边的
        while (oriArr[j]>=temp &&i<j) {
            j--;
        }
        //寻找右边的
        while (oriArr[i]<=temp &&i<j) {
            i++;
        }
        if (i<j) {
            //交换
            swiss(&oriArr[i], &oriArr[j]);
//            t = oriArr[i];
//            oriArr[i] = oriArr[j];
//            oriArr[j] = t;
        }
    }
    //先将基数保存到temp，当交换完成基数归位,第一次交换完成数组的left 值位置没有改变
    //基数归位
    oriArr[left] = oriArr[i];
    oriArr[i] = temp;

    //继续处理左边的
    test_quicksort(left, i-1);
    //继续处理右边的
    test_quicksort(i+1, right);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

归并排序 参考文章

//将有二个有序数列a[first...mid]和a[mid...last]合并。
/*
 首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可
 */
void merginArr(int a[],int first,int mid,int last,int temp[]){
    int i = first,j = mid +1;
    int m = mid,n = last;
    int k = 0;
    while (i<=m && j<= n) {
        if (a[i]<a[j]) {
            temp[k++] = a[i++];
        }else{
            temp[k++] = a[j++];
        }
    }
    while (i<=m) {
        temp[k++] = a[i++];
    }
    while (j<=n) {
        temp[k++] = a[j++];
    }

    for (int l=0; l<k; l++) {
        a[first + l] = temp[l];
    }
}
/*
 可以看出合并有序数列的效率是比较高的，可以达到O(n)。

 解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

 可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。
 */
void mergeSort(int a[],int first,int last,int temp[]){
    if (first<last) {
        int mid = (first+last)/2;
        //左边分组有序
        mergeSort(a, first, mid, temp);
        //右边分组有序
        mergeSort(a, mid+1, last, temp);
        //将两个有序数组合并
        merginArr(a, first, mid, last, temp);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

希尔排序 参考文章

void xier_sort(int arr[],int l){
    int i,j,step,len;
    len = l;
    for (step=len/2; step>0; step=step/2) {
        for (i=0; i<step; i++) {
            for (j=i +step; j<len; j=j+step) {
                if (arr[j]<arr[j-step]) {
                    int temp = arr[j];
                    int k = j - step;
                    while (k>=0 &&arr[k]>temp) {
                        arr[k+step] = arr[k];
                        k -= step;
                    }
                    arr[k + step] = temp;
                }
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

堆排序还在研究，就写到这里