十大排序算法

最新推荐文章于 2024-08-19 11:12:00 发布

李木华

最新推荐文章于 2024-08-19 11:12:00 发布

阅读量256

点赞数

分类专栏： C++ 文章标签：算法二叉树排序算法快速排序数据结构

本文链接：https://blog.csdn.net/Alfa_/article/details/115350907

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

排序算法

文章目录

排序算法

算法分类

十种常见的排序算法
- 比较类排序
  - 交换排序
    - 冒泡排序
    - 快速排序
  - 插入排序
    - 简单插入排序
    - 希尔排序
  - 选择排序
    - 简单选择排序
    - 堆排序
  - 归并排序
    - 二路归并排序
    - 多路归并排序
- 非比较类排序
  - 计数排序
  - 桶排序
  - 基数排序

算法性能

在这里插入图片描述

冒泡排序（bubble sort）

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

代码

void bubble_sort(vector<int> &vec)
{
    int size = vec.size();
    for (int i = 0; i < size - 1; ++i)
        for (int j = 0; j < size - 1 - i; ++j)
            if (vec[j] > vec[j + 1])
                swap(vec[j], vec[j + 1]);
}

选择排序（selection sort）

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

代码：

void selection_sort(vector<int> &vec)
{
    int size = vec.size();
    for (int i = 0; i < size - 1; ++i)
    {
        int min_index = i;
        for (int j = i + 1; j < size; ++j)
        {
            if (vec[min_index] > vec[j])
                min_index = j;
        }
        if (min_index != i)
            swap(vec[i], vec[min_index]);
    }
}

注意：选择排序在最好和最坏的情况下的时间复杂度都是O(n²)

插入排序（insert sort）

通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入

代码：

void insert_sort(vector<int> &vec)
{
    int size = vec.size();
    for (int i = 1; i < size; ++i)
    {
        int j = i - 1;
        int current = vec[i];
        while (j >= 0 and vec[j] > current)
        {
            vec[j + 1] = vec[j];
            --j;
        }
        vec[j + 1] = current;
    }
}

插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

希尔排序（shell sort）

简单插入排序的改进版，时间复杂度小于O(n²)，最坏情况为O(n²)。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序

代码：

void shell_sort(vector<int> &vec)
{
    int size = vec.size();
    for (int gap = size / 2; gap > 0; gap /= 2)
    {
        for (int i = gap; i < size; ++i)
        {
            int j = i - gap;
            int current = vec[i];
            while (j >= 0 and vec[j] > current)
            {
                vec[j + gap] = vec[j];
                j -= gap;
            }
            vec[j + gap] = current;
        }
    }
}

希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列，也可以动态的定义间隔序列。

归并排序（merge sort）

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

代码：

void merge(vector<int> &vec, vector<int> &temp, int start, int end)
{
    if (start >= end)
        return;
    int len = end - start;
    int mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge(vec, temp, start1, end1);
    merge(vec, temp, start2, end2);
    int k = start;
    while (start1 <= end1 and start2 <= end2)
        temp[k++] = vec[start1] < vec[start2] ? vec[start1++] : vec[start2++];
    while (start1 <= end1)
        temp[k++] = vec[start1++];
    while (start2 <= end2)
        temp[k++] = vec[start2++];
    for (k = start; k <= end; ++k)
        vec[k] = temp[k];
}

void merge_sort(vector<int> &vec)
{
    int size = vec.size();
    vector<int> temp(size);
    merge(vec, temp, 0, size - 1);
}

归并排序是稳定排序，它也是一种十分高效的排序，能利用完全二叉树特性的排序一般性能；每次合并操作的平均时间复杂度为O(n)，而完全二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。

归并排序的优化

插入排序：当待排序列长度为5~20之间，此时使用插入排序能避免一些有害的退化情形
- 小数据量可使用插入排序加快速度
```
if (end - start <= 10)
{
    insertSort(arr, start, end);
    return;
}
```

插入排序+测试待排序序列中左右半边是否已有序

int len = end - start;
int mid = start + (len >> 1);
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;
merge(arr, temp, start1, end1);
merge(arr, temp, start2, end2);
if (arr[mid] <= arr[mid + 1])
	return;

链表的归并排序

注意查找中间节点的判断条件fast->next != nullptr and fast->next->next != nullptr

ListNode *merge(ListNode *head)
{
    if (head == nullptr or head->next == nullptr)
        return head;
    ListNode *slow = head, *fast = head;
    while (fast->next != nullptr and fast->next->next != nullptr)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    ListNode *head2 = slow->next;
    slow->next = nullptr;
    ListNode *newhead1 = merge(head);
    ListNode *newhead2 = merge(head2);
    ListNode dummyhead;
    ListNode *curr = &dummyhead;
    while (newhead1 != nullptr and newhead2 != nullptr)
    {
        if (newhead1->val < newhead2->val)
        {
            curr->next = newhead1;
            newhead1 = newhead1->next;
        }
        else
        {
            curr->next = newhead2;
            newhead2 = newhead2->next;
        }
        curr = curr->next;
    }
    if (newhead1 != nullptr)
        curr->next = newhead1;
    if (newhead2 != nullptr)
        curr->next = newhead2;
    return dummyhead.next;
}

快速排序（quick sort）

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

代码：使用最后一个元素作为pivot（需要注意的是left和right两个循环的顺序问题，如果选择最后一个数作为基准值，则先进行left指针的循环，再进行right指针的循环；如果选择第一个数作为基准值，则先进行right指针的循环，再进行left指针的循环）

void quick_rec(vector<int> &vec, int start, int end)
{
    if (start >= end)
        return;
    // int index = rand() % (end - start + 1) + start;   // 随机选择
    // swap(vec[index], vec[end]);
    int pivot = vec[end];  // 这里选择最后一个数作为基准值
    int left = start, right = end;  
    while (left < right)
    {
        while (left < right and vec[left] < pivot)   // 首先必须对left指针进行操作
            ++left;
        while (left < right and vec[right] >= pivot)  // 再对right指针进行操作
            --right;
        swap(vec[left], vec[right]);
    }
    swap(vec[left], vec[end]);
    quick_rec(vec, start, left - 1);
    quick_rec(vec, left + 1, end);
}

void quick_sort(vector<int> &vec)
{
    int size = vec.size();
    quick_rec(vec, 0, size - 1);
}

分析：
- 在最优的情况下，快速排序算法的时间复杂度为O(nlogn)。
- 在最坏的情况下，最终其时间复杂度为O(n²)
- 快速排序的平均时间复杂度为O(nlogn)

快速排序优化

随机选取pivot

/*随机选择枢轴的位置，区间在low和high之间*/
int SelectPivotRandom(int arr[],int low,int high)
{
	srand((unsigned)time(NULL));//产生枢轴的位置
	int pivotPos = rand()%(high - low) + low;
 
	swap(arr[pivotPos],arr[low]);//把枢轴位置的元素和low位置元素互换，此时可以和普通的快排一样调用划分函数
	return arr[low];
}

三数取中

int getPivot(vector<int> &arr, int start, int end)
{
    int mid = start + (end - start) / 2;
    if (arr[mid] < arr[start])
        swap(arr[mid], arr[start]);
    if (arr[end] < arr[start])
        swap(arr[end], arr[start]);
    if (arr[mid] < arr[end])
        swap(arr[end], arr[mid]);
    return arr[end];
}

三数取中 + 插入排序：当待排序列长度为5~20之间，此时使用插入排序能避免一些有害的退化情形
- 快排需要的时间代价更多，因为递归需要大量指令以及内存空间来执行堆栈运行现场，函数调用等操作。对于极小规模数据而言，确实要比直接插入排序的代价更高
```
if (end - start < 10)
{
    insertSort(arr, start, end);
    return;
}//else时，正常执行快排
```

三数取中+插入排序+聚集相等元素：在一次分割结束后，可以把与pivot相等的元素聚在一起，继续下次分割时，不用再对与pivot相等元素分割

在划分过程中，把与pivot相等元素放入数组的两端
划分结束后，把与pivot相等的元素移到枢轴周围

int getPivot(vector<int> &arr, int start, int end)
{
    int mid = start + (end - start) / 2;
    if (arr[mid] < arr[start])
        swap(arr[mid], arr[start]);
    if (arr[end] < arr[start])
        swap(arr[end], arr[start]);
    if (arr[mid] < arr[end])
        swap(arr[end], arr[mid]);
    return arr[end];
}

void insertSort(vector<int> &arr, int start, int end)
{
    for (int i = start + 1; i <= end; ++i)
    {
        int j = i - 1;
        int curr = arr[i];
        while (j >= start and arr[j] > curr)
        {
            arr[j + 1] = arr[j];
            --j;
        }
        arr[j + 1] = curr;
    }
}

void gather(vector<int> &arr, int start, int end, int boundkey, int &left, int &right)
{
    if (start >= end)
        return;
    int count = boundkey - 1;
    for (int i = count; i >= start; --i)
    {
        if (arr[i] == arr[boundkey])
        {
            swap(arr[i], arr[count]);
            --count;
        }
    }
    left = count;
    count = boundkey + 1;
    for (int i = count; i <= end; ++i)
    {
        if (arr[i] == arr[boundkey])
        {
            swap(arr[i], arr[count]);
            ++count;
        }
    }
    right = count;
}

void quictSort(vector<int> &arr, int start, int end)
{
    if (end - start < 10)
    {
        insertSort(arr, start, end);
        return;
    }
    int pivot = getPivot(arr, start, end);
    int left = start, right = end;
    while (left < right)
    {
        while (left < right and arr[left] < pivot)   // 首先必须对left指针进行操作
            ++left;
        while (left < right and arr[right] >= pivot)  // 再对right指针进行操作
            --right;
        swap(arr[left], arr[right]);
    }
    swap(arr[left], arr[end]);
    gather(arr, start, end, left, left, right);
    quictSort(arr, start, left);
    quictSort(arr, right, end);
}

链表的快速排序

直接交换节点值：left和right初始条件

void quickSort(ListNode *head, ListNode *tail)
{
    if (head == tail or head->next == tail)
        return;
    int pivot = head->val;
    ListNode *left = head, *right = head->next;
    while (right != tail)
    {
        if (right->val < pivot)
        {
            left = left->next;
            swap(left->val, right->val);
        }
        right = right->next;
    }
    swap(left->val, head->val);
    ListNode *mid = left;
    quickSort(head, mid);
    quickSort(mid->next, tail);
}

只能交换节点：分成两个链表，分别保存小于和大于pivot值的节点，然后对两个链表分别排序，最后再组合

ListNode *quickSort(ListNode *head)
{
    if (head == nullptr or head->next == nullptr)
        return head;
    int pivot = head->val;
    ListNode left, right;
    ListNode *l = &left, *r = &right, *curr = head->next;
    while (curr != nullptr)
    {
        if (curr->val < pivot)
        {
            l->next = curr;
            l = l->next;
        }
        else
        {
            r->next = curr;
            r = r->next;
        }
        curr = curr->next;
    }
    l->next = r->next = nullptr;
    ListNode *left_res = quickSort(left.next);
    ListNode *right_res = quickSort(right.next);
    if (left_res == nullptr)
    {
        head->next = right_res;
        return head;
    }
    curr = left_res;
    while (curr->next != nullptr)
    {
        curr = curr->next;
    }
    curr->next = head;
    curr->next->next = right_res;
    return left_res;
}

堆排序（heap sort）

利用堆这种数据结构所设计的一种排序算法
堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点

代码：

void max_heapify(vector<int> &vec, int start, int end){    int parent = start;    int child = parent * 2 + 1; //左子节点    while (child <= end)    {        if (child + 1 <= end and vec[child] < vec[child + 1]) //选择左右子节点中的最大值            ++child;        if (vec[child] < vec[parent])            return;        swap(vec[parent], vec[child]);        parent = child;        child = parent * 2 + 1;    }}void heap_sort(vector<int> &vec){    int size = vec.size();    for (int i = size / 2; i >= 0; --i) //从最后一棵子树开始构造最大堆        max_heapify(vec, i, size - 1);    for (int i = size - 1; i > 0; --i)    {        swap(vec[0], vec[i]);       // 将最大元素与堆中最后一个元素交换        max_heapify(vec, 0, i - 1); // 前i-1个元素继续构造最大堆    }}

堆排序整体的时间复杂度是 O(nlogn)

计数排序（counting sort）

将输入的数据值转化为键存储在额外开辟的数组空间中，作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数
步骤：
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

代码：

void counting_sort(vector<int> &vec){    int size = vec.size();    int max_value = vec[0];    int min_value = vec[0];    for (int i = 1; i < size; ++i)    {        max_value = max_value < vec[i] ? vec[i] : max_value;        min_value = min_value > vec[i] ? vec[i] : min_value;    }    int len = max_value - min_value + 1;    vector<int> bucket(len, 0);    for (int i = 0; i < size; ++i)        bucket[vec[i] - min_value]++;    int sorted_index = 0;    for (int i = 0; i < len; ++i)    {        while (bucket[i] > 0)        {            vec[sorted_index++] = i + min_value;            --bucket[i];        }    }}

桶排序（bucket sort）

在额外空间充足的情况下，尽量增大桶的数量
使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中
当输入的数据可以均匀的分配到每一个桶中时最快
当输入的数据被分配到了同一个桶中时最慢
代码：略

基数排序（radix sort）

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
代码：略

李木华

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
十大排序算法

排序算法算法分类十种常见的排序算法比较类排序交换排序冒泡排序快速排序插入排序简单插入排序希尔排序选择排序简单选择排序堆排序归并排序非比较类排序计数排序桶排序基数排序算法性能冒泡排序（bubble sort）冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。代码void bubble_sort(vector<int> &vec){
复制链接

扫一扫

专栏目录