高
0%

C和数据结构——常见的几种排序算法和可执行实例

Posted on Edited on In
冒泡排序，插入排序等常见排序方法和实例
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#include <stdio.h>
#include <stdlib.h>
//冒泡排序
void Bubble_Sort(int num[], int n)
{
    int i, j, k, z;
    int change = true;
    for (i = 0; i <= n - 1 && change; i++)
    {
        change = false;
        for (j = 0; j <= n - 1; j++)
        {
            if (num[j] > num[j + 1])
            {
                k = num[j + 1];
                num[j + 1] = num[j];
                num[j] = k;
                change = true;
            }
        }
        printf("--\n第%d次遍历后的结果是:\n--", i + 1);
        for (z = 0; z <= n - 1; z++)
        {
            printf("%d\t", num[z]);
        }
    }
}
//快速排序
int QKPass(int num[], int low, int high)
{
    int x = num[low];
    int i, j;
    while (low < high)
    {
        //先找小于的数据
        while (low < high && x <= num[high])
            high--;
        if (low < high)
        {
            num[low] = num[high];
            low++;
        }
        //找大于的数据
        while (low < high && num[low] < x)
            low++;
        if (low < high)
        {
            num[high] = num[low];
            high--;
        }
    }
    num[low] = x;
    return low;
}
void QKSort(int num[], int low, int high)
{
    int pos;
    if (low < high)
    {
        pos = QKPass(num, low, high);
        QKPass(num, low, pos - 1);
        QKPass(num, pos + 1, high);
    }
}
int main()
{
    int z;
    int num[10] = {0, 62, 35, 77, 55, 14, 35, 98, 22, 40};
    int n = 10;
    // Bubble_Sort(num, n);
    QKSort(num, 0, 10);
    printf("\n");
    for (z = 1; z <= n - 1; z++)
    {
        printf("%d -- %p    \t", num[z]);
    }
}

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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
#include <stdio.h>
#include <stdlib.h>
//直接插入法
void D_insort(int num[])
{
    int L = 14;
    int j;
    int i;
    for (i = 2; i < L; i++)
    {
        num[0] = num[i];
        j = i - 1;
        while (num[0] < num[j])
        {
            num[j + 1] = num[j];
            j = j - 1;
        }
        num[j + 1] = num[0];
    }
    printf("这是直接插入法\n");
    for (i = 1; i < L; i++)
    {
        printf("%d\t", num[i]);
    }
}

//半插入法
void M_insert(int num[], int L)
{
    int i, j, low, high, mid;
    int k;
    for (i = 2; i < L; i++)
    {
        num[0] = num[i];
        low = 1;
        high = i - 1;
        while (low <= high)
        {
            mid = (low + high) / 2;
            if (num[i] < num[mid])
                high = mid - 1;
            else
                low = mid + 1;
        }
        for (j = i - 1; j > low; --j)
            num[j + 1] = num[j];
        num[low] = num[0]; //这里的low = mid+1,也就是

        printf("\n使用折半插入排序第%d轮的排序结果是:", i);
        for (k = 1; k <= L; k++)
        {
            printf("%d\t", num[k]);
        }
    }
    //输出最终结果
    printf("\n--------------------------------\n");
    for (k = 1; k <= L; k++)
    {
        printf("%d\t", num[k]);
    }
}

//希尔排序
void X_insert(int num[], int d)
{
    int i, j;
    int L = 13;
    for (i = 1 + d; i < L; i++)
    {
        if (num[i] < num[i - d])
        {
            num[0] = num[i];
            for (j = i - d; j > 0 && num[0] < num[j]; j -= d)
            {
                num[j + d] = num[j];
            }
            num[j + d] = num[0];
        }
    }
}
void X_insert_R(int num[], int d)
{
    int i;
    int L = 13;
    for (i = 0; i <= L - 1; ++i)
    {
        X_insert(num, d);
    }
    printf("这是希尔排序的结果\n");
    for (i = 1; i <= L - 1; ++i)
        printf("%d\t", num[i]);
}
int main()
{
    int num[] = {0, 1, 5, 3, 4, 2, 100, 99, 888, 80, 70, 249, 125};
    int *p = num;
    M_insert(p, 13);
    printf("\n------------------------------\n");
    D_insort(p);
    printf("\n-------------------------------\n");
    X_insert_R(p, 4);
}
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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

#include <stdio.h>
#include <stdlib.h>
//简单选择排序
void SelectSort(int num[], int n)
{
    int i;
    int j;
    for (i = 1; i <= n - 1; i++)
    {
        int k = i; //记录最小的数据的位置
        for (j = i + 1; j <= n - 1; j++)
        {
            if (num[j] < num[k])
                k = j;
            if (i != k)
            {
                int x = num[k];
                num[k] = num[i];
                num[i] = x;
            }
        }
    }
}

//树形选择排序
//堆排序
//重建堆
void sift(int num[], int k, int m)
{                   //m是总的数据的个数，代表数组的最后的一个位置
    int t = num[k]; //暂存根数据
    int i = k;
    int j = i * 2; //j是k孩子的位置，就是子树
    int FD = false;
    while (j < m && !FD)
    {
        if (j + 1 < m && num[j] < num[j + 1])
        {
            j = j + 1; //找到子树中最大的那个数据所在的位置
        }
        if (t > num[j])
        {
            FD = true; //执行这一句话的时候说明所有的数都没有根结点的数值大，则就表示生成了一个堆，而且是大根堆
        }
        else
        {
            //说明子树里的最大孩子比根数的值大，则交换二者的值，同时这只是对根结点找到了最大那个值，还要对
            num[i] = num[j];
            i = j;     //
            j = 2 * i; //
        }
    }
    num[i] = t; //
}
//建初堆算法
void crt_heap(int num[], int n)
{
    for (int i = (n / 2); i >= 1; --i)
    {
        sift(num, i, n);
    }
}
//堆排序
void HeapSort(int num[], int n)
{
    crt_heap(num, n);
    int i;
    for (i = n; i >= 2; --i)
    {
        int b = num[1];
        num[1] = num[i];
        num[i] = b;
        sift(num, 1, i - 1);
    }
}
int main()
{
    int i;
    int num[6] = {0, 5, 4, 3, 2, 1};
    //SelectSort(num, 6);
    //printf("简单选择排序的结果是:\n");
    HeapSort(num, 5);
    for (i = 0; i < 6; i++)
        printf("%d", num[i]);
}