排序算法————数据结构//复习复习复习

排序算法

汇总

插入排序

void InsertSort(int A[], int n)  //时间复杂度O(n)O(n^2) 空间复杂度O(1) 稳定性 稳定
{//直接插入 从后面拿一个往前面插 定位置时暴力
    for (int i = 2; i <= n; i++) //设第一个元素为排好的序列
    {
        if (A[i] < A[i - 1]) //与排好序列的最后一个比较
        {
            A[0] = A[i]; //暂存数据 也为下面跳出循环做准备
            int j;
            for (j = i - 1; A[0] < A[j]; --j) //从排好的序列最后找
                A[j + 1] = A[j];              //边找边移
            A[j + 1] = A[0];                  //将值 赋值到已找到的位置
        }
    }
}
void Insert_Sort(int A[], int n) //时间复杂度O(nlogn)O(n^2) 空间复杂度O(1) 稳定性 稳定
{//折半插入 从后面拿一个往前面插 定位置时二分
    for (int i = 2; i <= n; i++) //设第一个元素为排好的序列
    {
        if (A[i] < A[i - 1]) //与排好序列的最后一个比较
        {
            A[0] = A[i]; //暂存数据 也为下面作比较做准备
            int low = 1, high = i - 1;
            while (low <= high)
            { //查到第一个大于A[0]的数据
                int mid = (low + high) / 2;
                if (A[mid] > A[0])
                    high = mid - 1;
                else
                    low = mid + 1;
            } //利用二分定位尽头high+1
            int j;
            for (j = i - 1; j >= high + 1; --j) //倒着移动 尽头为high+1
                A[j + 1] = A[j];
            A[j + 1] = A[0]; //将值 赋值到已找到的位置
        }
    }
}

希尔排序

void ShellSort(int A[], int n)             //时间复杂度O() O(n^2) 空间复杂度O(1) 稳定性 不稳定
{//希尔排序 先分成好几个组 在每个组内进行插入排序 组数减少后再排序
    for (int dk = n / 2; dk >= 1; dk /= 2) //设置步长 dk=3则1 4 7一组 然后dk变2 则1 3 5 7一组
    {
        for (int i = dk + 1; i <= n; i++) //设组内第一个元素为排好的序列
        {
            if (A[i] < A[i - dk]) //与组内排好序列的最后一个比较
            {
                A[0] = A[i]; //暂存数据
                int j;
                for (j = i - dk; j > 0 && A[0] < A[j]; j -= dk) //从组内排好的序列最后找
                    A[j + dk] = A[j];                           //边找边移
                A[j + dk] = A[0];                               //将值 赋值到已找到的位置
            }
        }
    }
}

冒泡排序

void BubbleSort(int A[], int n) //时间复杂度O(n^2) 空间复杂度O(1) 稳定性 稳定
{
    for (int i = 1; i < n; i++) //走n-1趟 第n趟的数值一定在最大位
    {
        bool flag = false;                         //每一趟的标记 用来简化时间复杂度
        for (int j = n; j > i; j--)                //从最后开始 换不换都向前走 类似于部分优化
            if (A[j] < A[j - 1])                   //从最后开始找 与前一个比
                swap(A[j - 1], A[j]), flag = true; //必前面小的话跟前面的换
        if (!flag)                                 //走了一趟没有交换 直接跳
            return;
    }
}

快速排序

int Partition(int A[], int low, int high)
{
    int temp = A[low]; //先确定一个数 作为轴 想象成low位已空
    while (low < high)
    {
        while (low < high && A[high] >= temp)
            high--;
        A[low] = A[high]; //找到一个比轴大的 补到low位 high位已空
        while (low < high && A[low] <= temp)
            low++;
        A[high] = A[low]; //找到一个比轴小的 补到high位 low位已空
    }
    A[low] = temp; //最后的空位由轴补
    return low;    //返回轴
}
void QuickSort(int A[], int low, int high) //时间复杂度O(nlogn) 空间复杂度O(1) 稳定性 不稳定
{
    if (low < high) //还没分到尽
    {
        int p = Partition(A, low, high); //一个数组变两个 但数组的大小不定
        QuickSort(A, low, p - 1);        //前一个数组
        QuickSort(A, p + 1, high);       //后一个数组
    }
}

选择排序

void SelectSort(int A[], int n) //时间复杂度O(n^2) 空间复杂度O(1) 稳定性 不稳定
{
    for (int i = 1; i < n; i++) //走n-1趟
    {
        int min = i;                     //记录最小元素位置
        for (int j = i + 1; j <= n; j++) //从后面开始找
            if (A[j] < A[min])
                min = j;
        if (min != i) //如果第一个不是最小的 换
            swap(A[i], A[min]);
    }
}

堆排序

void HeadAdjust(int A[], int k, int n)
{                                       //大堆调整
    A[0] = A[k];                        //根数据暂存
    for (int i = 2 * k; i <= n; i *= 2) //每次循环后 若还能走 则必定k=i
    {
        if (i < n && A[i] < A[i + 1]) //两孩子比较 取大 定的左孩子故不可=n
            i++;
        if (A[0] >= A[i]) //根大于两个孩子中较大的
            break;
        else
            A[k] = A[i], k = i; //根小了 孩子往里塞 空位为孩子位 将来要补的位
    }
    A[k] = A[0]; //暂存数据归位
}
void BuildMaxHeap(int A[], int n)
{                                   //优化数组成大堆
    for (int i = n / 2; i > 0; i--) //从有孩子的结点开始 在原数组上优化成堆
        HeadAdjust(A, i, n);
}
void HeapSort(int A[], int n)   //时间复杂度O(nlogn) 空间复杂度O(1) 稳定性 不稳定
{                               //先将数组调整至堆 在抽堆头放到该放的位置
    BuildMaxHeap(A, n);         //先调整成大堆
    for (int i = n; i > 1; i--) //走n-1趟 每次都是拿堆顶后再优化
    {
        swap(A[i], A[1]);        //拿堆头 放到该放的位置
        HeadAdjust(A, 1, i - 1); //调整剩下的堆的元素
    }
}

归并排序

void Merge(int A[],int low,int mid,int high)
{
    for (int k=low;k<=high;k++)//先小小记录一下
        b[k]=A[k];
    int i=low,j=mid+1;//双指针预备
    int k=i;
    while (i<=mid&&j<=high)//两个指针都能在自己回合走
        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(int A[],int low,int high)//时间复杂度O(nlogn) 空间复杂度O(n) 稳定性 稳定
{//采取的2路归并
    if (low<high)//懒到不会动
    {
        int mid=(low+high)/2;//懒到只会在中间分 2路归并
        MergeSort(A,low,mid);//给下手1
        MergeSort(A,mid+1,high);//给下手2
        Merge(A,low,mid,high);//请函数大佬整理一下
    }  
}

基数排序

/**
 * 基数排序 按关键字排 对于三位数 从右向左 
 * d:关键数数量3 n:元素数 r:关键字的可能取值数10
 * 时间复杂度O(d*(n+r)) 空间复杂度O(r) 稳定性 稳定
 **/