排序算法总结（考研）

咖色的杯

已于 2023-06-04 21:36:28 修改

阅读量228

点赞数

文章标签：排序算法考研算法

于 2022-11-26 21:38:28 首次发布

本文链接：https://blog.csdn.net/qq_45722156/article/details/128057368

版权

文章目录

1. 直接插入

#include <stdio.h>
#include "malloc.h"

/*
 * 1. 直插
 */

void insert_sort(int A[], int n) {
    for (int i = 2; i <= n; ++i) {
        int j;
        if (A[i - 1] > A[i]) {
            A[0] = A[i];
            for (j = i - 1; A[j] > A[0]; --j) {
                A[j + 1] = A[j];
            }
            A[j + 1] = A[0];
        }
    }
}

void out(int A[], int n) {
    for (int i = 1; i <= n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[11] = {10000, 2, 3, 4, 6, 0, 10, 1, 2, 9, 5};
    int n = 10;
    insert_sort(A, n);
    out(A, n);
}

2. 二分查找直接插入

#include <stdio.h>
#include "malloc.h"

/*
 * 2. 二分查找直插
 */

void insert_sort_by_binary_search(int A[], int n) {
    int i, j, low, high, mid;
    for (i = 2; i <= n; ++i) {
        if (A[i - 1] > A[i]) {
            A[0] = A[i];
            low = 1, high = i - 1;
            // 找到最终位置 high+1
            while (low <= high) {
                mid = (low + high) / 2;
                if (A[0] < A[mid]) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
            // 数据移动
            for (j = i - 1; j >= high + 1; --j) {
                A[j + 1] = A[j];
            }
            A[j + 1] = A[0];
        }
    }
}

void out(int A[], int n) {
    for (int i = 1; i <= n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[11] = {10000, 2, 3, 4, 6, 0, 10, 1, 2, 9, 5};
    int n = 10;
    insert_sort_by_binary_search(A, n);
    out(A, n);
}

3. 希尔排序

#include <stdio.h>

/*
 * 3. 希尔排序
 */

void shell_sort(int A[], int n) {
    int gap, i, j;
    for (gap = n / 2; gap >= 1; gap /= 2) { // gap循环
        for (i = gap + 1; i <= n; i++) { // i 循环
            if (A[i-gap] > A[i]){
                A[0] = A[i];
                for (j = i - gap; j > 0  && A[j] > A[0]; j -= gap) { // j 循环
                    A[j+gap] = A[j];
                }
                A[j+gap] = A[0];
            }
        }
    }
}


/*
 * 3.2 希尔排序
 * A[0]不是哨兵了, 并且是分趟排的，类比手算时的思路
 */

void shell_sort2(int A[], int n) {
    int gap, i, j;
    for (gap = n / 2; gap >= 1; gap /= 2) { // gap循环
        for (i = 0; i < gap; i++) { // gap次
            for (j = gap + i; j < n; j += gap) { //直接插入
                if (A[j - gap] > A[j]) {
                    int temp = A[j];
                    int k = j - gap;
                    while (k >= 0 && A[k] > temp) { // 找到最终位置
                        A[k + gap] = A[k];
                        k -= gap;
                    }
                    A[k + gap] = temp;
                }
            }
        }
    }
}

void out(int A[], int n) {
    for (int i = 1; i <= n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[11] = {10000, 2, 3, 4, 6, 0, 10, 1, 2, 9, 5};
    int n = 10;
    shell_sort(A, n);
    out(A, n);
}

4. 冒泡排序

#include <stdio.h>
#include "malloc.h"

# define True 1
# define False 0

/*
 * 4. 冒泡排序
 */

void swap(int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

void bubble_sort(int A[], int n) {
    for (int i = 0; i < n-1; ++i) { // 循环n-1次
        int flag = False;
        for (int j = n - 1; j > i; --j) { // 从后往前 将最小的元素放到第一个
            if (A[j - 1] > A[j]) {
                swap(&A[j - 1], &A[j]);
                flag = True;
            }
        }
        if (!flag) {
            return;
        }
    }
}

void out(int A[], int n) {
    for (int i = 0; i < n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[10] = {2, 3, 4, 6, 0, 10, 1, 2, 9, 5};
    int n = 10;
    bubble_sort(A, n);
    out(A, n);
}

5. 快速排序

#include <stdio.h>
#include "malloc.h"

/*
 * 5. 快速排序
 */

int partition(int A[], int low, int high) {
    int pivot = A[low];
    while (low < high) { // 最终位置为low = high
        while (low < high && A[high] >= pivot) high--;
        A[low] = A[high];
        while (low < high && A[low] <= pivot) low++;
        A[high] = A[low];
    }
    A[low] = pivot;
    return low;
}

void quick_sort(int A[], int low, int high) {
    if (low < high) {
        int pivotPos = partition(A, low, high);
        quick_sort(A, low, pivotPos - 1);
        quick_sort(A, pivotPos + 1, high);
    }

}

void out(int A[], int n) {
    for (int i = 0; i < n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[10] = {5, 2, 3, 4, 6, 0, 10, 1, 2, 9};
    int n = 10;
    int low = 0, high = n-1;
    quick_sort(A, low, high);
    out(A, n);
}

6. 选择排序

#include <stdio.h>
#include "malloc.h"

/*
 * 6.选择排序
 */
void swap(int *a, int *b) {
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

void select_sort(int A[], int n) {
    for (int i = 0; i < n - 1; ++i) { // n-1次 0 ~ n-2
        int min = i;
        for (int j = i + 1; j < n; ++j) { // i+1 ~ n-1
            if (A[min] > A[j]) {
                min = j;
            }
        }
        if (min != i) {
            swap(&A[min], &A[i]);
        }
    }
}

void out(int A[], int n) {
    for (int i = 0; i < n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[10] = {5, 2, 3, 4, 6, 0, 10, 1, 2, 9};
    int n = 10;
    select_sort(A, n);
    out(A, n);
}

7. 堆排序

#include <stdio.h>
#include "malloc.h"

/*
 * 7.堆排序
 */

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heap_adjust(int A[], int k, int n) {
    A[0] = A[k];
    for (int i = 2 * k; i <= n; i *= 2) {
        if (i < n && A[i] < A[i + 1]) i++;
        if (A[0] > A[i]) break;
        else {
            A[k] = A[i];
            k = i;
        }
    }
    A[k] = A[0];
}

void build_max_heap(int A[], int n) {
    // 从后往前 n/2 ~ 1
    for (int i = n / 2; i >= 1; --i) {
        heap_adjust(A, i, n);
    }
}

void heap_sort(int A[], int n) {
    // 创建堆
    build_max_heap(A, n);
    // 调整n-1次根为1的堆 从 n~2
    for (int i = n; i > 1; i--) {
        swap(&A[i], &A[1]);
        heap_adjust(A, 1, i - 1); // ★
    }
}

void out(int A[], int n) {
    for (int i = 1; i <= n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[11] = {0, 5, 2, 3, 4, 6, 0, 10, 1, 2, 9};
    int n = 10;
    heap_sort(A, n);
    out(A, n);
}

8. 归并排序

#include <stdio.h>
#include "stdlib.h"

/*
 * 8. 归并排序
 */

int B[11]; // 辅助数组

void merge(int A[], int low, int mid, int high) {
    int i, j, p;
    for (p = low; p <= high; ++p) B[p] = A[p];

    for (p = low, i = low, j = mid + 1; i <= mid && j <= high; p++) {
        // 都是B中的比较, 不改变的
        if (B[i] < B[j]) A[p] = B[i++];
        else A[p] = B[j++];
    }

    while (i <= mid) A[p++] = B[i++];
    while (j <= high) A[p++] = B[j++];

}

void merge_sort(int A[], int low, int high) {
    if (low < high) {
        int mid = (low + high) / 2;
        merge_sort(A, low, mid);
        merge_sort(A, mid + 1, high);
        merge(A, low, mid, high);
    }

}

void out(int A[], int n) {
    for (int i = 1; i <= n; ++i) {
        printf("%d\t", A[i]);
    }
}

int main() {
    int A[11] = {0, 5, 2, 3, 4, 6, 0, 10, 1, 2, 9};
    int n = 10;
    merge_sort(A, 1, 10);
    out(A, n);
}