算法 || c++实现各种经典内部排序

经典的排序算法如下：

• 插入排序
  • 直接插入排序
  • 折半插入排序
  • 希尔排序
• 交换排序
  • 冒泡排序
  • 鸡尾酒排序（双向冒泡）
  • 快速排序
• 选择排序
  • 简单选择排序
  • 堆排序
• 归并排序
• 基数排序 / 桶排序

代码实现：

//
//  main.cpp
//  sort
//
//  Created by peiyu wang on 2019/3/28.
//  Copyright © 2019 peiyu wang. All rights reserved.
//

#include <iostream>
#include <vector>
#include <ctime>
#include <cstdlib>
using namespace std;

const vector<int> dlta = {7, 5, 3, 1};

/* 插入排序 */

// 直接插入排序
void InsertSort(vector<int> &v)
{
    int i = 0;
    for (i = 2; i < v.size(); i++)
    {
        v[0] = v[i];
        int j = 0;
        for (j = i - 1; v[0] < v[j] ;j--)
        {
            v[j+1] = v[j];
        }
        v[j+1] = v[0];
    }
}
// 折半插入排序
// 在排好序的位置进行折半查找
// 减少了关键字的比较次数，可是移动的时间复杂度不变，所以仍为N*N
void Binary_InsertSort(vector<int> &v)
{
    int i = 0;
    for (i = 2; i < v.size(); i++)
    {
        v[0] = v[i];
        int low = 1;
        int high = i - 1;
        int mid = 0;
        while (low <= high)
        {
            mid = (low + high) / 2;
            if (v[mid] > v[0])
            {
                high = mid - 1;
            }
            else
            {
                low = mid + 1;
            }
        }
        for (int j = i - 1; j >= low; j--)
        {
            v[j+1] = v[j];
        }
        v[low] = v[0];
    }
}

void Shell_Insert(vector<int> &v, int dx)
{
    int i = 0;
    for (i = dx + 1; i < v.size(); i++)
    {
        v[0] = v[i];
        int j = 0;
        for (j = i - dx; j > 0 && v[j] > v[0] ;j -= dx)
        {
            v[j + dx] = v[j];
        }
        v[j + dx] = v[0];
    }
}

// 希尔排序
// 缩小增量的方法进行排序
void Shell_Sort(vector<int> &v)
{
    for (int i = 0; i < dlta.size(); i++)
    {
        Shell_Insert(v, dlta[i]);
    }
}

/* 交换排序 */
// 冒泡排序
void BubbleSort(vector<int> &v)
{
    int i = 0;
    for (i = int(v.size()) - 1; i >= 2; i--)
    {
        for (int j = 1; j < i; j++)
        {
            if (v[j] > v[j+1])
            {
                int tmp = v[j];
                v[j] = v[j+1];
                v[j+1] = tmp;
            }
        }
    }
}

// 快速排序
void QuickSort(vector<int> &v, int low, int high)
{
    int min = low;
    int max = high;
    v[0] = v[low];
    while (low < high)
    {
        while (v[high] >= v[0] && low < high)
        {
            high--;
        }
        while (v[low] <= v[0] && low < high)
        {
            low++;
        }
        int tmp = v[low];
        v[low] = v[high];
        v[high] = tmp;
    }
    v[min] = v[low];
    v[low] = v[0];
    if (low > 1 + min)
        QuickSort(v, min, low - 1);
    if (low < max - 1)
        QuickSort(v, low + 1, max);
}

// 鸡尾酒排序
void CockTailSort(vector<int> &v)
{
    for (int i = int(v.size()) - 1; i >= (int(v.size()) - 1) / 2; i--)
    {
        for (int j = int(v.size()) - i; j < i; j++)
        {
            if (v[j] > v[j+1])
            {
                int tmp = v[j];
                v[j] = v[j+1];
                v[j+1] = tmp;
            }
        }
        for (int j = i; j > int(v.size()) - i; j--)
        {
            if (v[j] < v[j - 1])
            {
                int tmp = v[j];
                v[j] = v[j - 1];
                v[j - 1] = tmp;
            }
        }
    }
}

/* 选择排序 */
// 堆排序
void CreateHeap(vector<int> &v, int root, int max)
{
    int t_max = v[root];
    int t_num = root;
    if (2 * root <= max)
    {
        if (v[2 * root] > t_max)
        {
            t_num = 2 * root;
            t_max = v[t_num];
        }
        if (2 * root + 1 <= max && v[2 * root + 1] > t_max)
        {
            t_num = 2 * root + 1;
            t_max = v[t_num];
        }
        if (t_num != root)
        {
            int tmp = v[root];
            v[root] = t_max;
            v[t_num] = tmp;
            CreateHeap(v, t_num, max);
        }
    }
}

void HeapSort(vector<int> &v)
{
    for (int i = (int(v.size()) - 1) / 2; i >= 1; i--)
    {
        CreateHeap(v, i, int(v.size()) - 1);
    }
    for (int i = 1; i < int(v.size()) - 1; i++)
    {
        int max = int(v.size()) - i;
        int tmp = v[1];
        v[1] = v[max];
        v[max] = tmp;
        CreateHeap(v, 1 , max - 1);
    }
}


// 归并排序
void Merge(vector<int> &v, int low, int high)
{
    if (low != high)
    {
        int mid = (low + high) / 2;
        int i = low;
        int j = mid + 1;
        vector<int> v0;
        while (i <= mid && j <= high)
        {
            if (v[i] > v[j])
            {
                v0.push_back(v[j]);
                j++;
            }
            else
            {
                v0.push_back(v[i]);
                i++;
            }
        }
        while (i <= mid)
        {
            v0.push_back(v[i]);
            i++;
        }
        while (j <= high)
        {
            v0.push_back(v[j]);
            j++;
        }
        for (int k = 0; k < high - low + 1; k++)
        {
            v[k + low] = v0[k];
        }
    }
}

void MergeSort(vector<int> &v, int low, int high)
{
    if (low != high)
    {
        int mid = (low + high) / 2;
        // 左边归并排序
        MergeSort(v, low, mid);
        // 右边归并排序
        MergeSort(v, mid + 1, high);
        // 左右归并
        Merge(v, low, high);
    }
}

int main(int argc, const char * argv[]) {
    // insert code here...
    srand(int(time(0)));
    vector<int> n;
    int num = 0, min = 0, max = 0;
    cout << "请输入你想排序的列表元素个数：" << endl;
    cin >> num;
    n.push_back(0);
    cout << "请输入你想产生的随机数的范围：" << endl;
    cout << "请输入最小值：" << endl;
    cin >> min;
    cout << "请输入最大值：" << endl;
    cin >> max;
    while (num--)
    {
        int tmp;
        tmp = rand() % (max - min + 1) + min;
        n.push_back(tmp);
    }
    cout << "随机产生的数组为：" << endl;
    ostream_iterator<int> out(cout, " ");
    copy(n.begin() + 1, n.end(), out);
    cout << endl;
    //Shell_Sort(n);
    //QuickSort(n, 1, int(n.size()) - 1);
    //HeapSort(n);
    //CockTailSort(n);
    MergeSort(n, 1, int(n.size()) - 1);
    //ostream_iterator<int> out(cout, " ");
    cout << "排序后的数组是：" << endl;
    copy(n.begin() + 1, n.end(), out);
    cout << endl;
    return 0;
}