数据结构-排序

排序
排序

算法种类		时间复杂度		空间复杂度	是否稳定
	最好情况	最坏情况	最坏情况
直接插入排序	$O(n)$	$O(n^2)$	$O(n^2)$	$O(1)$	是
冒泡排序	$O(n)$	$O(n^2)$	$O(n^2)$	$O(1)$	是
简单选择排序	$O(n)$	$O(n^2)$	$O(n^2)$	$O(1)$	否
希尔排序					否
快速排序	$O(nlo{g}_2)$	$O(nlo{g}_2)$	$O(n^2)$	$O(lo{g}_{2}n)$	否
堆排序	$O(nlo{g}_2)$	$O(nlo{g}_2)$	$O(nlo{g}_2)$	$O(1)$	否
二路归并排序	$O(nlo{g}_2)$	$O(nlo{g}_2)$	$O(nlo{g}_2)$	$O(n)$	是
基数排序	$O(d(n+r))$	$O(d(n+r))$	$O(d(n+r))$	$O(r)$	是

main.cpp

#include <iostream>
#include <time.h>
#include <fstream>
#include <cstring>
#include "SortTest.h"
using namespace std;
typedef int ElemType;
void inputArr(ElemType A[], int &n);
void outputArr(ElemType A[], int n);

int main()
{
    ElemType A[100];
    int n;
    inputArr(A, n); //输入函数
    B = (ElemType *)malloc((n + 1) * sizeof(ElemType));
    //直接插入排序
    // InsertSort( A, n);
    //希尔排序
    //ShellSort(A,n);
    //冒泡排序
    // BubbleSort(A,n);
    // QuikSort(A, 1, n);
    // SelectSort(A, n);
    // 堆排序
    // HeapSort(A, n);
    // 归并排序
    MergeSort(A, 1, n);
    outputArr(A, n); //输出函数
    return 0;
}





void inputArr(ElemType A[], int &n)
{
    cout << "请输入数组规模n的大小：" << endl;
    cin >> n;
    //待排元素从下表1开始存储，A[0]留着为哨兵位置
    for (int i = 1; i <= n; ++i)
    {
        cin >> A[i];
    }
}
void outputArr(ElemType A[], int n)
{
    for (int i = 1; i <= n; ++i)
    {
        cout << A[i] << " ";
    }
}
/*
9
6 5 8 7 4 2 1 3 9
*/

SortTest.h

//
// Created by Administrator on 2021/11/4 0004.
//
#ifndef UNTITLED_SORTTEST_H
#define UNTITLED_SORTTEST_H
typedef int ElemType;
int Partition(ElemType A[], int low, int high);
void InsertSort(ElemType A[], int n)
{
    int i, j;
    for (i = 2; i <= n; i++)
    {
        if (A[i] < A[i - 1])
        {
            A[0] = A[i];
            for (j = i - 1; A[0] < A[j]; --j)
            {
                A[j + 1] = A[j];
            }
            A[j + 1] = A[0];
        }
    }
}
void ShellSort(ElemType A[], int n)
{
    int i, j, dk;
    for (dk = n / 2; dk >= 1; dk = dk / 2)
    {
        for (i = dk + 1; i <= n; ++i)
        {
            if (A[i] < A[i - dk])
            {
                A[0] = A[i];
                for (j = i - dk; j >= 0 & A[j] > A[0]; j -= dk)
                {
                    A[j + dk] = A[j];
                }
                A[j + dk] = A[0];
            }
        }
    }
}
void BubbleSort(ElemType A[], int n)
{
    for (int i = 1; i < n; ++i)
    {
        bool flag = false;
        for (int j = n; j > i; j--)
        {
            if (A[j] < A[j - 1])
            {
                ElemType temp;
                temp = A[j];
                A[j] = A[j - 1];
                A[j - 1] = temp;
                flag = true;
            }
        }
        if (!flag)
            return;
    }
}
void QuikSort(ElemType A[], int low, int high)
{
    if (low < high)
    {
        int pivotpos = Partition(A, low, high);
        QuikSort(A, low, pivotpos - 1);
        QuikSort(A, pivotpos + 1, high);
    }
}
int Partition(ElemType A[], int low, int high)
{
    ElemType pivot = A[low];
    while (low < high)
    {
        while (low < high && A[high] >= pivot)
            --high;
        A[low] = A[high];
        while (low < high && A[low] <= pivot)
            ++low;
        A[high] = A[low];
    }
    A[low] = pivot;
    return low;
}

void SelectSort(ElemType A[], int n)
{
    for (int i = 1; i <= n; i++)
    {
        int min = i;
        for (int j = i + 1; j < n; j++)
        {
            if (A[j] <= A[min])
                min = j;
        }
        if (min != i)
        {
           ElemType temp=A[min];
           A[min]=A[i];
           A[i]=temp;
        }
    }
}

void HeadAdjust(ElemType A[], int k, int len)
{
    A[0] = A[k];
    for (int i = k * 2; i <= len; i *= 2)
    {
        if (i < len && A[i] < A[i + 1])
            i++;
        if (A[0] >= A[i])
            break;
        else
        {
            A[k] = A[i];
            k = i;
        }
        A[k] = A[0];
    }
}
void BuidMaxHeap(ElemType A[], int len)
{
    for (int i = len / 2; i > 0; i--)
    {
        HeadAdjust(A, i, len);
    }
}
void HeapSort(ElemType A[], int len)
{
    BuidMaxHeap(A, len);
    for (int i = len; i > 1; --i)
    {
        ElemType temp = A[i];
        A[i] = A[1];
        A[1] = temp;
        HeadAdjust(A, 1, i - 1);
    }
}

ElemType *B;
void Merge(ElemType A[], int low, int mid, int high)
{
    int i, j, k;
    for (k = low; k <= high; k++)
        B[k] = A[k];
    for (i = low, j = mid + 1, k = i; i <= mid && j <= high; k++)
    {
        if (B[i] <= B[j])
            A[k] = B[i++];
        else
            A[k] = B[j++];
    }
    while (i <= mid)
        A[k++] = B[i++];
    while (j <= high)
        A[k++] = B[j++];
}
void MergeSort(ElemType A[], int low, int high)
{
    if (low < high)
    {
        int mid = (low + high) / 2;
        MergeSort(A, low, mid);
        MergeSort(A, mid + 1, high);
        Merge(A, low, mid, high);
    }
}
#endif //UNTITLED_SORTTEST_H