各种排序算法实现

//  此版本为调整优化好的快速排序算法实现。
# include <iostream>
# include <vector>
using namespace std;
int Partition(vector<int> &arr, int low, int high)
{
    int pivot;                // 划分后基准记录的位置
    int pivotkey = arr[low]; // 用区间的第一个值作为基准，也可以采用其他方式,比如三数取中
    while (low < high)
    {
        while (low < high && arr[high] >= pivotkey) // 先从右向左扫描
            high--;
        if (low < high)      // 每次必须有判断，因为有可能在此时出现low>high的情况
            arr[low++] = arr[high];
        while (low < high && arr[low] <= pivotkey) // 再从左向右扫描
            low++;
        if(low < high)
            arr[high--] = arr[low];
    }
    pivot = low;           // 找出基准位置
    arr[pivot] = pivotkey; // 基准位置定位
    return pivot;
}
// 典型的分治法的思想
void quicksort(vector<int> &arr, int low, int high)
{
    if (low < high)  // 仅当区间长度大于 1 时才排序
    {
        int pivot = Partition(arr, low, high);  // 分解，找出基准
        quicksort(arr, low, pivot-1);           // 递归求解左子区间
        quicksort(arr, pivot + 1, high);        // 递归求解右子区间
    }
}
int main ()
{
    vector<int> arr;
    int temp;
    while (cin >> temp)
    {
        arr.push_back(temp); // 将数存入数组
    }
    quicksort(arr, 0, arr.size() - 1);
    for(auto i : arr)
        cout << i << endl;
    return 0;
}

// 优化的冒泡算法实现
# include <iostream>
# include <vector>
using namespace std;
void BubbleSort(vector<int> &arr)
{
    int i , j, temp,len;
    len =  arr.size();
    for (i = 0; i < len - 1; i++)  // 外层循环控制无序区的终点位置
    {
        bool flag = true;
        for (j = len - 1; j > i; j--) //内层控制每次比较的位置
        {
            if (arr[j] < arr[j - 1])
            {
                temp = arr[j];
                arr[j] = arr[j -1];
                arr[j - 1] = temp;
                flag = false;
            }
        }
        if (flag)
            break;
    }
}
int main()
{
    vector<int> arr;
    int temp;
    while (cin >> temp)
    {
        arr.push_back(temp); // 将数存入数组
    }
    BubbleSort(arr);
    cout <<"after sort: "<< endl;
    for(auto i : arr)
        cout << i << endl;
    return 0;
}

// 简单选择算法实现,相比于冒泡排序，最大的特点是数据交换移动次数较少，找到合适的关键字（最小值的位置）再交换
# include <iostream>
# include <vector>
using namespace std;
void SelectSort(vector<int> &arr)
{
    int i , j, temp,len, minindex;
    len =  arr.size();
    for (i = 0; i < len - 1; i++)  // 外层循环控制无序区的起点位置
    {
        minindex = i;
        for (j = i + 1; j <= len ; j++) //内层控制每次比较的位置,注意范围控制
        {
            if (arr[j] < arr[minindex])
                minindex = j;
        }
        if (minindex != i)  // 若有比当前值还小的最小值，则将最小值放到无序区的起点位置
        {
            temp = arr[minindex];
            arr[minindex] = arr[i];
            arr[i] = temp;
        }
    }
}
int main()
{
    vector<int> arr;
    int temp;
    while (cin >> temp)
    {
        arr.push_back(temp); // 将数存入数组
    }
    SelectSort(arr);
    cout <<"after sort: "<< endl;
    for(auto i : arr)
        cout << i << endl;
    return 0;
}

// 直接插入排序算法实现: 基本操作是讲一个记录插入到已经排好序的有序表汇总，
// 从而得到 一个新的、记录数增1的有序表
// 时间复杂度： O(n^2)
// author: SimplePaul
# include <iostream>
# include <vector>
using namespace std;
void InsertSort(vector<int> &arr)
{
    int i , j, temp,len;
    len =  arr.size();
    for (i = 1; i <= len - 1; i++)  //
    {
        if(arr[i] < arr[i-1])   // 若当前比前一个小，则需要交换，否则不交换
        {
            temp = arr[i];    // 保存当前的值
            for ( j = i - 1; arr[j] > temp && j >= 0; j--) // j>= 0的条件容易忘
            {
                arr[j + 1] = arr[j];   // 记录后移，直到当前值比temp要小
            }
            arr[j + 1] = temp;
        }
    }
}
int main()
{
    vector<int> arr;
    int temp;
    while (cin >> temp)
    {
        arr.push_back(temp); // 将数存入数组
    }
    InsertSort(arr);
    cout <<"after sort: "<< endl;
    for(auto i : arr)
        cout << i << endl;
    return 0;
}

// 希尔排序算法实现: 希尔排序(Shell Sort)是插入排序的一种，它是针对直接插入排序算法的改进
// 该方法又称缩小增量排序,希尔排序实质上是一种分组插入方法。它的基本思想是：对于n个待排序的数列，
//取一个小于n的整数gap(gap被称为步长)将待排序元素分成若干个组子序列，所有距离为gap的倍数的记录
//放在同一个组中；然后，对各组内的元素进行直接插入排序。 这一趟排序完成之后，每一个组的元素都是
//有序的。然后减小gap的值，并重复执行上述的分组和排序。重复这样的操作，当gap=1时，整个数列就是有序的。

// 相当于是     插入排序只是执行了希尔排序的gap=1的情况
// 时间复杂度： O(nlog(n))~O(n^2)  ,不稳定排序
// author: SimplePaul

# include <iostream>
# include <vector>
using namespace std;
void ShellSort(vector<int> &arr)
{
    int i , j, temp,len,gap;
    len =  arr.size();
    gap = len / 2;       // 取增量
    while (gap >= 1)
    {

        for (i = gap; i <= len - 1; i += gap)  // 进行插入排序，相当于原来每次插入排序的间隔为1，现在为gap
        {
            if(arr[i] < arr[i - gap]) // 若当前比前一个(前一个指相差gap的前一个值)小，则需要交换，否则不交换
            {
                temp = arr[i];        // 保存当前的值
                for ( j = i - gap; arr[j] > temp && j >= 0; j -= gap) // j>= 0的条件容易忘
                {
                    arr[j + gap] = arr[j];   // 每次记录后移gap，直到当前值比temp要小
                }
                arr[j + gap] = temp;   
            }
        }
        gap /= 2;   // 设置新的增量
    }

}
int main()
{
    vector<int> arr;
    int temp;
    while (cin >> temp)
    {
        arr.push_back(temp); // 将数存入数组
    }
    ShellSort(arr);
    cout <<"after sort: "<< endl;
    for(auto i : arr)
        cout << i << endl;
    return 0;
}

 堆排序实现：参考源

// 堆排序实现：
// 复杂度： O(NlogN)
//堆排序与快速排序，归并排序一样都是时间复杂度为O(N*logN)的几种常见排序方法

#include <iostream>
using namespace std;
// 最大堆的向下调整算法  MaxHeapDown（）
// 数组实现的堆中，第N个结点的左孩子的索引值是（2N+1），右孩子的索引是（2N+2）
// 其中，N为数组下标索引值，如数组第一个数对应的N为0。
// 参数说明：
//          a: 待排序的数组
//          start: 被下调节点的起始位置（一般为0，表示从第一个开始）
//          ends: 截止范围（一般为数组中最后一个元素的索引）
void MaxHeapDown(int* a, int start, int ends)
{
    int c = start;  // 当前(current)节点的位置
    int l = 2 * c + 1; // 左（left）孩子的位置
    int tmp = a[c];    // 当前节点的大小
    for (; l <= ends; c = l, l = 2*l + 1)
    {
        // l 是左孩子， l + 1 是右孩子
        if ( l < ends && a[l] < a[l + 1])
            l++;  // 左右两个孩子中选择较大者
        if (tmp >= a[l])
            break;   // 若当前节点的值比两个孩子中的大者还大 就结束循环
        //若是需要交换则执行下面的步骤
        a[c] = a[l];
        a[l] = tmp;
    }
}
// 堆排序（从小到大）：  a : 待排数组；  n： 数组的长度
void HeapSortAsc(int *a, int n)
{
    int i, tmp;
    // 从(n/2 - 1) --> 0 顺序遍历，之后得到的数组实际上是一个最大二叉堆
    // 即从第一个有孩子的节点开始遍历调整，
    for (i = n / 2 - 1; i >= 0; i--) // 相当于建好一个堆
        MaxHeapDown(a, i, n - 1);

    //从最后一个元素开始对序列进行调整，直到第一个元素
    for (i = n - 1; i > 0; i--)
    {
        // 交换a[0]和 a[i],交换后a[i]是数组中最大的
        tmp = a[0];
        a[0] = a[i];
        a[i] = tmp;
        //再调整a[0>>>>i-1]，使得其仍为一个最大堆
        MaxHeapDown(a, 0, i - 1);
    }
}
int main()
{
    int i;
    int a[] = {20,30,90,40,70,110,60,10,100,50,80};
    int len = (sizeof(a) / (sizeof(a[0])));
    cout << "before sort:";
    for (i = 0; i < len; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    HeapSortAsc(a, len);
    cout << "after sort:";
    for (i = 0; i < len; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    return 0;
}

// 一个例子：寻找最小的K个数

归并排序：待更新。。。