经典排序算法(C++实现)

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/weixin_38169413/article/details/81627871

##各个排序算法的比较


以下排序算法均使用

void Sort(ElemType a[], int n)

类似的格式，其中，a为待排序的数组，n为数组元素个数。
###归并排序

/*******************************************************************************
功    能: 归并排序
创建时间：2018-06-20
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>
#include <malloc.h>
using namespace std;

typedef int ElemType;

/*exchange the  value i and j of the array*/
void Swap(ElemType a[], int i, int j)
{
    ElemType temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

/*两个有序子列的合并*/
void Merge(ElemType a[], ElemType temp[], int left_begin, int right_begin, int right_end)
{
    int left_end = right_begin - 1;
    int i = left_begin; //存放结果数组的初始位置
    int num_element = right_end - left_begin + 1;
    //进行合并
    while (left_begin <= left_end && right_begin <= right_end)
    {
        if (a[left_begin] <= a[right_begin])
            temp[i++] = a[left_begin++];
        else
            temp[i++] = a[right_begin++];
    }
    while (left_begin <= left_end)
        temp[i++] = a[left_begin++];
    while (right_begin <= right_end)
        temp[i++] = a[right_begin++];

    //改变a中对应段的值
    for (int j = 0; j < num_element; j++)
    {
        a[right_end] = temp[right_end];
        right_end--;
    }
}

/*递归进行*/
void MSort(ElemType a[], ElemType temp[], int begin, int end)
{
    int mid;
    if (begin < end)
    {
        mid = (begin + end) / 2;
        MSort(a, temp, begin, mid);
        MSort(a, temp, mid + 1, end);
        Merge(a, temp, begin, mid + 1, end);
    }
}

/*归并排序*/
void MergeSort(ElemType a[], int n)
{
    ElemType *temp = (int *)malloc(sizeof(int) * n);
    if (temp != NULL)
    {
        MSort(a, temp, 0, n - 1);
        free(temp);
    }
    else
        cout << "空间不足！" << endl;
}

//=================================下面是非递归方法===========================//
/*两个有序子列的合并*/
void Merge1(ElemType a[], ElemType temp[], int left_begin, int right_begin, int right_end)
{
    int left_end = right_begin - 1;
    int i = left_begin; //存放结果数组的初始位置
    int num_element = right_end - left_begin + 1;
    //进行合并
    while (left_begin <= left_end && right_begin <= right_end)
    {
        if (a[left_begin] <= a[right_begin])
            temp[i++] = a[left_begin++];
        else
            temp[i++] = a[right_begin++];
    }
    while (left_begin <= left_end)
        temp[i++] = a[left_begin++];
    while (right_begin <= right_end)
        temp[i++] = a[right_begin++];
}

/*非递归*/
void MergePass(ElemType a[], ElemType temp[], int n, int length)
{
    int i;
    for (i = 0; i <= n - 2 * length; i += 2 * length)
        Merge1(a, temp, i, i + length, i + 2 * length - 1);
    if (i + length < n)
        Merge1(a, temp, i, i + length, n - 1);
    else
        for (int j = i; j < n; j++)
            temp[j] = a[j];
}

/*非递归归并排序*/
void MergeSort2(ElemType a[], int n)
{
    int length = 1;
    ElemType *temp = (int *)malloc(sizeof(int) * n);

    if (temp != NULL)
    {
        while (length < n)
        {
            MergePass(a, temp, n, length);
            length *= 2;
            MergePass(temp, a, n, length);
            length *= 2;
        }
        free(temp);
    }
    else
        cout << "空间不足！" << endl;
}


int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;

    // MergeSort(a, 10);
    // cout << "递归归并排序：";
    // for (int i = 0; i < n; i++)
    // {
    //     cout << a[i] << " ";
    // }
    MergeSort2(a, 10);
    cout << "非递归归并排序：";
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

快速排序

/*******************************************************************************
功    能: 快速排序
创建时间：2018-06-05
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>

using namespace std;
typedef int ElemType;



/*exchange the  value i and j of the array*/
void swap(ElemType a[],int i,int j)
{
	ElemType temp = a[i];
	a[i]  = a[j];
	a[j] = temp;
}

/*快速排序函数*/
//输入：待排序的数组,排序其实位置>=0,排序终止位置<=length(a) - 1
void QuickSortHelper(ElemType a[],int low,int high)
{
    if(low >= high)
        return;
    ElemType temp = a[low];  //存储序列首位元素
    int i = low + 1;
    int j = high;
    while(i != j)
    {
        while(i < j && a[j] > temp)
            j--;
        while(i < j && a[i] < temp)
            i++;
        //交换两个元素
        if(i < j)
        {
            swap(a,i,j);
        }
    }
    a[low] = a[i];
    a[i] = temp;

    QuickSortHelper(a,low,i -1);
    QuickSortHelper(a,i + 1,high);
}

/*快速排序*/
void QuickSort(ElemType a[], int n)
{
    QuickSortHelper(a,0,n-1);
}

int main()
{
    int a[10] = {3,1,4,6,8,9,10,5,7,2};
    cout <<"快速排序：";
    QuickSort(a,10);
    for(int i = 0; i < 10;i++)
    {
        cout << a[i] <<" ";
    }
    cout << endl;
    return 0;
}

堆排序

/*******************************************************************************
功    能: 堆排序
创建时间：2018-06-20
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>

using namespace std;

typedef int ElemType;

/*exchange the  value i and j of the array*/
void Swap(ElemType a[], int i, int j)
{
    ElemType temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

/*调整为最大堆*/
void PercDown(ElemType a[], int p, int n)
{
    // 将N个元素的数组中以a[p]为根的子堆调整为关于a[i]的最小堆
    int parent, child;
    int x;

    x = a[p]; //取出根节点的值

    for (parent = p; (parent * 2 + 1) < n; parent = child)
    {
        child = parent * 2 + 1;
        if ((child != n - 1) && (a[child] < a[child + 1]))
            child++;
        if (x >= a[child])
            break;
        else
            a[parent] = a[child];
    }
    a[parent] = x;
}


/*堆排序*/
void HeapSort(ElemType a[], int n)
{
    for (int i = n / 2; i >= 0; i--)
        PercDown(a, i, n);    //建立一个最大堆
    for (int i = n - 1; i > 0; i--)
    {
        Swap(a, 0, i);  //交换最大最小元素，把最大元素给a[i]
        PercDown(a, 0, i); //剩下的i个元素调整为最大堆
    }
}

int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;

   HeapSort(a, 10);
    cout << "堆排序：";
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

冒泡排序

/*******************************************************************************
功    能: 冒泡排序
创建时间：2018-06-19
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>

using namespace std;

typedef int ElemType;

/*exchange the  value i and j of the array*/
void Swap(ElemType a[], int i, int j)
{
    ElemType temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

/*基础冒泡排序*/
void BubbleSort0(ElemType a[] ,int n)
{
    int i, j;
    for (int i = 0; i < n; i++)
    {
        for (int j = i + 1; j < n; j++)
        {
            if (a[i] > a[j])
                Swap(a, i, j);
        }
    }
}

/*经典冒泡排序*/
void BubbleSort(ElemType a[] ,int n)
{
    int i, j;
    for (int i = 0; i < n; i++)
    {
        for (int j = n - 2; j >= i; j--)
        {
            if (a[j] > a[j + 1])
            {
                Swap(a, j, j + 1);
            }
        }
    }
}

/*冒泡排序改进版*/
void BubbleSort2(ElemType a[] ,int n)
{
    int i, j;
    bool flag = true;
    for (int i = 1; i < n && flag == true; i++)
    {
        flag = false;
        for (int j = n - 2; j >= i; j--)
        {
            if (a[j] > a[j + 1])
            {
                flag = true;
                Swap(a, j, j + 1);
            }
        }
    }
}

int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;

    // BubbleSort0(a, 10);
    // cout << "原始冒泡排序：";
    // for (int i = 0; i < n; i++)
    // {
    //     cout << a[i] << " ";
    // }
    // cout << endl;
    BubbleSort(a, 10);
    cout << "冒泡排序：";
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
    // BubbleSort2(a, 10);
    // cout << "改进冒泡排序：";
    // for (int i = 0; i < n; i++)
    // {
    //     cout << a[i] << " ";
    // }
    // cout << endl;
}

插入排序

/*******************************************************************************
功    能: 插入排序
创建时间：2018-06-19
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>

using namespace std;

typedef int ElemType;

/*exchange the  value i and j of the array*/
void Swap(ElemType a[], int i, int j)
{
    ElemType temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

/*插入排序*/
void InsertSort(ElemType a[],int n)
{
    for(int i = 1;i < n;i++)
    {
        ElemType temp = a[i];
        int j;
        for(j = i;j > 0 && a[j - 1] > temp;j--)
        {
            a[j] = a[j-1];
        }
        a[j] = temp;
    }
}

int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;

    InsertSort(a, 10);
    cout << "插入排序：";
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

希尔排序

/*******************************************************************************
功    能: 希尔排序
创建时间：2018-06-20
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>

using namespace std;

typedef int ElemType;

/*exchange the  value i and j of the array*/
void Swap(ElemType a[], int i, int j)
{
    ElemType temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

/*希尔排序*/
void ShellSort(ElemType a[], int n)
{
    for (int d = n / 2; d > 0; d = d / 2)
    {
        for (int i = d; i < n; i++)
        {
            ElemType temp = a[i];
            int j;
            for (j = i; j >= d && a[j - d] > temp; j -= d)
            {
                a[j] = a[j - d];
            }
            a[j] = temp;
        }
    }
}

int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;

    ShellSort(a, 10);
    cout << "希尔排序：";
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

选择排序

/*******************************************************************************
功    能: 选择排序
创建时间：2018-06-20
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>

using namespace std;

typedef int ElemType;

/*exchange the  value i and j of the array*/
void Swap(ElemType a[], int i, int j)
{
    ElemType temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

/*选择排序*/
void SelectionSort(ElemType a[],int n)
{
	int i,j,min;
	for(i = 0;i < n; i++)
	{
		min = i;
		for(int j = i + 1; j < n; j++)
		{
			if(a[j] < a[min])
				min = j;
		}
		if(i != min)
			Swap(a,i,min);
	}

}
int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;

    SelectionSort(a, 10);
    cout << "选择排序：";
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

表排序

/*******************************************************************************
功    能: 表排序
创建时间：2018-06-20
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>

using namespace std;

typedef int ElemType;

/*exchange the  value i and j of the array*/
void Swap(ElemType a[], int i, int j)
{
    ElemType temp = a[i];
    a[i] = a[j];
    a[j] = temp;
}

void InsertSort(ElemType a[],ElemType table[],int n)
{
    for(int i = 1;i < n;i++)
    {
        ElemType temp = table[i];
        int j;
        for(j = i;j > 0 && a[table[j-1]] > a[temp];j--)
        {
            table[j] = table[j-1];
        }
        table[j] = i;
    }
}

/*表排序*/
void TableSort(ElemType a[], ElemType table[], int n)
{
    for (int i = 0; i < n; i++)
        table[i] = i;
    InsertSort(a,table, n);
}

int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;
    ElemType table[n];
    TableSort(a, table,10);
    cout << "表排序：";
    for (int i = 0; i < n; i++)
    {
        //cout << a[i] <<" ";
        cout << table[i] << " ";
    }
    cout << endl;
}

基数排序

/*******************************************************************************
功    能: 基数排序
创建时间：2018-06-21
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>
#include <vector>
using namespace std;

typedef int ElemType;

int GetDigitNum(int x)
{
    if (x == 0)
        return 1;
    int res = 0;
    while (x)
    {
        res++;
        x /= 10;
    }
    return res;
}

/*基数排序*/
void RadixSort(ElemType a[], int n)
{
    //求最大值的位数
    int max = a[0];
    for (int i = 1; i < n; i++)
    {
        if (max < a[i])
            max = a[i];
    }
    int maxNum = GetDigitNum(max);

    int divisor = 1;
    vector<int> g[10]; //g[i]中包含了"末位"数字是i的a[]数组中的元素
    for (int k = 0; k < maxNum; k++)
    {

        for (int i = 0; i < 10; i++)
            vector<int>().swap(g[i]);
        for (int i = 0; i < n; i++)
        {
            int tmp = a[i] / divisor % 10;
            g[tmp].push_back(a[i]);
        }

        int cnt = 0;
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < g[i].size(); j++)
            {
                a[cnt++] = g[i][j];
            }
        }

        divisor *= 10;
    }
}

int main(int argc, char *argv[])
{
    int a[10] = {3, 1, 4, 6, 8, 9, 10, 5, 7, 2};
    int n = 10;

    RadixSort(a, 10);
    cout << "基数排序：";
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " ";
    }
    cout << endl;
}

多关键字排序

/*******************************************************************************
功    能: 多关键字排序
创建时间：2018-06-21
作    者：Elvan
修改时间：
作    者：
*******************************************************************************/
#include <iostream>
#include <vector>
using namespace std;
struct ElemType
{
    int first; //主位
    int least; //次位
};

int
GetDigitNum(int x)
{
    if (x == 0)
        return 1;
    int res = 0;
    while (x)
    {
        res++;
        x /= 10;
    }
    return res;
}

void RadixSort_first(ElemType a[], int n)
{
    //求最大值的位数
    int max = a[0].first;
    for (int i = 1; i < n; i++)
    {
        if (max < a[i].first)
            max = a[i].first;
    }
    int maxNum = GetDigitNum(max);

    int divisor = 1;
    vector<ElemType> g[5]; //g[i]中包含了"末位"数字是i的a[].first数组中的元素
    for (int k = 0; k < maxNum; k++)
    {

        for (int i = 0; i < 5; i++)
            vector<ElemType>().swap(g[i]);
        for (int i = 0; i < n; i++)
        {
            int tmp = a[i].first / divisor % 10;
            g[tmp].push_back(a[i]);
        }

        int cnt = 0;
        for (int i = 0; i < 5; i++)
        {
            for (int j = 0; j < g[i].size(); j++)
            {
                a[cnt++] = g[i][j];
            }
        }
        divisor *= 10;
    }
}

void RadixSort_least(ElemType a[], int n)
{
    //求最大值的位数
    int max = a[0].least;
    for (int i = 1; i < n; i++)
    {
        if (max < a[i].least)
            max = a[i].least;
    }
    int maxNum = GetDigitNum(max);

    int divisor = 1;
    vector<ElemType> g[10]; //g[i]中包含了"末位"数字是i的a[].least数组中的元素
    for (int k = 0; k < maxNum; k++)
    {

        for (int i = 0; i < 10; i++)
            vector<ElemType>().swap(g[i]);
        for (int i = 0; i < n; i++)
        {
            int tmp = a[i].least / divisor % 10;
            g[tmp].push_back(a[i]);
        }

        int cnt = 0;
        for (int i = 0; i < 10; i++)
        {
            for (int j = 0; j < g[i].size(); j++)
            {
                a[cnt++] = g[i][j];
            }
        }
        divisor *= 10;
    }
}

int main(int argc, char *argv[])
{
    ElemType a[10];
    a[0].first = 2;
    a[0].least = 78;
    a[1].first = 3;
    a[1].least = 88;
    a[2].first = 1;
    a[2].least = 3;
    a[3].first = 3;
    a[3].least = 69;
    a[4].first = 3;
    a[4].least = 35;
    a[5].first = 1;
    a[5].least = 28;
    a[6].first = 2;
    a[6].least = 178;
    a[7].first = 1;
    a[7].least = 12;
    a[8].first = 2;
    a[8].least = 778;
    a[9].first = 1;
    a[9].least = 1;

    int n = 10;

    RadixSort_least(a, 10);
    RadixSort_first(a, 10);
    cout << "基数排序："<<endl;
    for (int i = 0; i < n; i++)
    {
        cout << a[i].first << " " << a[i].least <<endl;
    }
    cout << endl;
}

其中，实例参考了浙江大学数据结构教程。视频链接