插入\希尔\选择\归并\冒泡\快速\堆排序实现

插入排序

算法原理

插入排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

代码实现

void insertion_sort(int arr[], int n) {
    for (int i = 1; i < n; i++) {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

性能分析

插入排序的时间复杂度为O(n^2)，在实际应用中，当数据量较小时，插入排序的性能较好；当数据量较大时，其性能较差。

希尔排序

算法原理

希尔排序是一种改进的插入排序算法。它的基本思想是将待排序的数组按照一定的间隔分组，对每组进行插入排序，然后逐渐缩小间隔，直到间隔为1，此时整个数组已经基本有序，再进行一次插入排序即可。

代码实现

void shell_sort(int arr[], int n) {
    for (int gap = n / 2; gap > 0; gap /= 2) {
        for (int i = gap; i < n; i++) {
            int temp = arr[i];
            int j = i - gap;
            while (j >= 0 && arr[j] > temp) {
                arr[j + gap] = arr[j];
                j -= gap;
            }
            arr[j + gap] = temp;
        }
    }
}

性能分析

希尔排序的时间复杂度为O(n^2)，在实际应用中，当数据量较小时，希尔排序的性能较好；当数据量较大时，其性能较差。

选择排序

算法原理

选择排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从未排序部分找出最小（或最大）元素，将其放到已排序序列的末尾。

代码实现

void selection_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        int min_index = i;
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[min_index]) {
                min_index = j;
            }
        }
        if (min_index != i) {
            int temp = arr[i];
            arr[i] = arr[min_index];
            arr[min_index] = temp;
        }
    }
}

性能分析

选择排序的时间复杂度为O(n^2)，在实际应用中，当数据量较小时，选择排序的性能较好；当数据量较大时，其性能较差。

归并排序

算法原理

归并排序是一种分治算法。它的基本原理是将待排序的数组分为两部分，分别对这两部分进行归并排序，然后将排序后的两部分合并成一个有序序列。

代码实现

void merge(int arr[], int left[], int left_size, int right[], int right_size) {
    int i = 0, j = 0, k = 0;
    while (i < left_size && j < right_size) {
        if (left[i] < right[j]) {
            arr[k++] = left[i++];
        } else {
            arr[k++] = right[j++];
        }
    }
    while (i < left_size) {
        arr[k++] = left[i++];
    }
    while (j < right_size) {
        arr[k++] = right[j++];
    }
}

void merge_sort(int arr[], int size) {
    if (size < 2) {
        return;
    }
    int mid = size / 2;
    int left[mid], right[size - mid];
    for (int i = 0; i < mid; i++) {
        left[i] = arr[i];
    }
    for (int i = mid; i < size; i++) {
        right[i - mid] = arr[i];
    }
    merge_sort(left, mid);
    merge_sort(right, size - mid);
    merge(arr, left, mid, right, size - mid);
}

性能分析

归并排序的时间复杂度为O(nlogn)，在实际应用中，当数据量较小时，归并排序的性能较好；当数据量较大时，其性能优于其他排序算法。

冒泡排序

算法原理

冒泡排序是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从前向后扫描，找到相邻两个未排序元素中较大的一个，将其与未排序元素交换位置。

代码实现

void bubble_sort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

性能分析

冒泡排序的时间复杂度为O(n^2)，在实际应用中，当数据量较小时，冒泡排序的性能较好；当数据量较大时，其性能较差。

快速堆排序

算法原理

快速堆排序是一种基于二叉堆数据结构的排序算法。它的基本原理是将待排序的数组构建成一个大顶堆（或小顶堆），然后将堆顶元素与堆尾元素交换，将剩余的元素重新调整为大顶堆（或小顶堆），重复这个过程，直到堆中只剩下一个元素。

代码实现

void quick_sort(int arr[], int left, int right) {
    if (left >= right) {
        return;
    }
    int i = left, j = right, pivot = arr[left];
    while (i < j) {
        while (i < j && arr[j] >= pivot) {
            j--;
        }
        if (i < j) {
            arr[i++] = arr[j];
        }
        while (i < j && arr[i] < pivot) {
            i++;
        }
        if (i < j) {
            arr[j--] = arr[i];
        }
    }
    arr[i] = pivot;
    quick_sort(arr, left, i - 1);
    quick_sort(arr, i + 1, right);
}

性能分析

快速堆排序的时间复杂度为O(nlogn)，在实际应用中，当数据量较小时，快速堆排序的性能较好；当数据量较大时，其性能优于其他排序算法。