各种排序算法总结

最新推荐文章于 2024-10-22 17:17:53 发布

原创最新推荐文章于 2024-10-22 17:17:53 发布 · 113 阅读

0 ·

CC 4.0 BY-SA版权

算法题专栏收录该内容

118 篇文章

订阅专栏

本文详细介绍了八种经典的排序算法，包括插入排序、冒泡排序、选择排序、希尔排序、归并排序、堆排序、快速排序及其非递归实现。每种算法都提供了详细的C++代码实现，帮助读者深入理解各种排序算法的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1：插入排序

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

2：冒泡排序

C++
//bubble dort
void bubble_sort(int arr[],int len)
{
    int i;
    int j;
    for(int i = 0;i < len;++i)
    {
        for(int j = i + 1;j < len;++j)
        {
            if(arr[i] > arr[j])
                swap(arr[i],arr[j]);
        }
    }
}

3：选择排序

C++
//selection sort
void selection_sort(int arr[],int len)
{
    for(int i = 0;i < len;++i)
    {
        int min = i;
        for(int j = i+1;j < len;++j)
        {
            if(arr[j] < arr[min])
                min = j;
        }
        swap(arr[min],arr[i]);
    }
}

4：希尔排序

C++
//shell_sort
void shell_sort(int arr[],int length)
{
    int h = 1;
    while(h < length / 3)
    {
        h = h * 3 + 1;
    }
    while(h >= 1)
    {
        for(int i = h;i < length;++i)
        {
            for(int j = i;j >= h&&arr[j] < arr[j-h];j-=h)
            {
                swap(arr[j],arr[j-h]);
            }
        }
        h = h/3;
    }
}

5：归并排序

C++
//merge sort
void merge(vector<int>& arr,int front,int mid,int end)
{
    vector<int> left(arr.begin() + front,arr.begin() + mid + 1);
    vector<int> right(arr.begin() + mid + 1,arr.begin() + end + 1);
    int indexleft = 0;
    int indexright = 0;
    left.insert(left.end(),INT32_MAX);
    right.insert(right.end(),INT32_MAX);
    for(int i = front;i <= end;++i)
    {
        if(left[indexleft] < right[indexright])
        {
            arr[i] = left[indexleft];
            ++indexleft;
        }
        else {
            arr[i] = right[indexright];
            ++indexright;
        }
    }
}

void merge_sort(vector<int>& arr,int front,int end)
{
    if(front >= end)
        return;
    int mid = front + (end - front)/2;
    merge_sort(arr,front,mid);
    merge_sort(arr,mid + 1,end);
    merge(arr,front,mid,end);
}

6：堆排序

C++
//heap sort
//当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。一般二叉树简称为堆。
//一般都是数组来存储堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2
void Heap_build(vector<int>& arr,int start,int end)
{
    int dad = start;
    int son = dad*2 + 1;
    while(son < end)
    {
        if(son + 1 <= end&&arr[son] < arr[son + 1])
            son = son + 1;
        if(arr[son] < arr[dad])
            break;
        else {
            swap(arr[son],arr[dad]);
            Heap_build(arr,son,end);
        }
    }
}
void Heap_sort(vector<int>& arr,int len)
{
    for(int i = len/2 - 1;i >= 0;--i)
        Heap_build(arr,i,len - 1);
    for(int i = len - 1;i >= 0;--i)
    {
        swap(arr[0],arr[i]);
        Heap_build(arr,0,i - 1);
    }
}

7：快速排序

C++
//quick sort
int partition(vector<int>& arr,int start,int end)
{
    if(start > end)
        return start;
    int flag = arr[start];
    int left = start;
    int right = end;
    while(left < right)
    {
        while(left < right&&arr[right] >= flag)--right;
        arr[left] = arr[right];
        while(left < right&&arr[left] <= flag)++left;
        arr[right] = arr[left];
    }
    arr[left] = flag;
    return left;
}
void QuickSort(vector<int>& arr,int left,int right)
{
    if(left > right)
        return;
    int mid = partition(arr,left,right);
    QuickSort(arr,left,mid - 1);
    QuickSort(arr,mid + 1,right);
}

用栈实现的快速排序（非递归）

C++
int partition(int arr[],int left,int right)
{
    int key = arr[left];
    while(left < right)
    {
        while(left < right&&arr[right] >= key)--right;
        arr[left] = arr[right];
        while(left < right&&arr[left] <= key)++left;
        arr[right] = arr[left];
    }
    arr[left] = key;
    return left;
}

void Quicksort(int arr[],int length)
{
    if(length <= 1)
        return;
    stack<int> s;
    s.push(0);
    s.push(length-1);
    int left,right,mid;
    while(!s.empty())
    {
        right = s.top();
        s.pop();
        left = s.top();
        s.pop();
        mid = partition(arr,left,right);
        if(mid-1 > left)
        {
            s.push(left);
            s.push(mid-1);
        }
        if(mid+1 < right)
        {
            s.push(mid+1);
            s.push(right);
        }
    }
}