常用排序算法

参考链接>>

冒泡排序

// 冒泡排序 Bubble sort

// 比较相邻的元素，如果第一个元素比第二个元素大，就交换他们两个
// 从第一对开始，到结尾的最后一对

void sort_pupple(int arr[], int length)
{
    for (int i = 0; i < length; ++i)
    {
        for (int j = 0; j < length - 1 - i; ++j)  // 这一步进行了一个优化，遍历顺序不需要进行到最后
        {
            if (arr[j] > arr[j+1])
            {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        } 
    }
}
// 算法分析，经过优化的冒泡排序，例如添加一个flag标志说明是否存在逆序对，那么最好情况下时间复杂度为O(n)
int main()
{
    int arr[] = {1,3,5,2,3,4,5,6};
    sort_pupple(arr, sizeof(arr) / sizeof(int));
    for (auto & elem : arr)
    {
        cout << elem << ' ';
    }
    cout << '\n';
}

选择排序

// 选择排序 Selection sort
// 每次从未排序数组中选择最小元素，放在起始位置
void sort_selection(int arr[], int length)
{
    if (arr == nullptr)
        return;
    int min_index = 0;
    for (int i = 0; i < length - 1; ++i)
    {
        min_index = i;
        for (int j = i + 1; j < length; ++j)
        {
            if (arr[min_index] > arr[j])
            {
                min_index = j;
            }
        }
        // 找到最小索引位置
        int tmp = arr[i];
        arr[i] = arr[min_index];
        arr[min_index] = tmp;
    }
}
// 算法分析：稳定，不占用额外空间，时间复杂度一定是O(n2)
int main()
{
    int arr[] = {1,3,5,2,3,4,5,6};
    sort_pupple(arr, sizeof(arr) / sizeof(int));
    for (auto & elem : arr)
    {
        cout << elem << ' ';
    }
    cout << '\n';
}

插入排序

// 插入排序
// 通过构建有序序列，对于未排序数组，在已排序数组中从后向前扫描，找到相应位置并插入
void sort_insert(int arr[], int length)
{
    for (int i = 1; i < length; ++i)
    {
        int preIndex = i - 1;
        int current = arr[i]; // 把该值保留下来
        while (preIndex >= 0 && arr[preIndex] > current)
        {
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex] = current;
    }
}

int main()
{
    int arr[] = {1,3,5,2,3,9,5,6};
    sort_pupple(arr, sizeof(arr) / sizeof(int));
    for (auto & elem : arr)
    {
        cout << elem << ' ';
    }
    cout << '\n';
}
// 算法分析：in_plac操作，空间复杂度为O(1)，时间复杂度最好为O(n)，最坏为O(n2)

归并排序

// 归并排序
void merge_sort_core(int arr[], int l, int r)
{
    if (l >= r) return;

    int middle = (l + r) >> 1;
    merge_sort_core(arr, l, middle);
    merge_sort_core(arr, middle + 1, r);

    int tmp[r - l + 5];
    int i = l, j = middle + 1, k = 0;
    while (i <= middle && j <= r)
    {
        if (arr[i] <= arr[j])
            tmp[k++] = arr[i++];
        else
            tmp[k++] = arr[j++];
    }

    while (i <= middle)  tmp[k++] = arr[i++];
    while (j <= r)       tmp[k++] = arr[j++];
    
    for (i = l, j = 0; i <= r; ++i, ++j)
    {
        arr[i] = tmp[j];
    }
}
void merge_sort(int arr[], int length)
{
    merge_sort_core(arr, 0, length - 1);
}

int main()
{
    int arr[] = {1,3,5,2,3,9,5,6};
    merge_sort(arr, sizeof(arr) / sizeof(int));
    for (auto & elem : arr)
    {
        cout << elem << ' ';
    }
    cout << '\n';
}
// 算法分析：采用分治法的典型应用，将已有序的子序列合并，得到完全有序的序列。先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一张表，称为二路归并。

快速排序

// 快速排序
void quick_sort(int arr[], int l, int r)
{
    if (l >= r)
        return;
    int num = arr[(l + r) >> 1];
    int i = l - 1, j = r + 1;
    while (i < j)
    {
        do ++i; while (arr[i] < num);
        do --j; while (num < arr[j]);
        if (i < j){
            swap(arr[i], arr[j]);
        }
    }
    quick_sort(arr, l, j);
    quick_sort(arr, j + 1, r);
}

int main()
{
    int arr[] = {1,3,5,2,3,9,5,6};
    quick_sort(arr, 0, (sizeof(arr) / sizeof(int)) - 1);
    for (auto & elem : arr)
    {
        cout << elem << ' ';
    }
    cout << '\n';
}