进阶算法(二) 《算法笔记》哨兵的使用 1、简单选择排序 2、直接插入排序 3、归并排序 4、快速排序 5、随机选择算法 6、堆排序

1、简单选择排序 

#include <cstdio>

int main()
{
    int arr[11];
    for (int i = 1; i <= 10; ++i)
        scanf("%d", &arr[i]);
    //n个元素进行n - 1轮
    //每一轮把最小的元素置于排序好的序列尾部, 逐次向后更新
    int i, j;
    for (i = 1; i < 10; i++)
    {
        //保留哨兵位置
        for (j = i + 1; j <= 10; j++)
        {
            if (arr[j] < arr[i])
            {
                //交换
                arr[0] = arr[i];
                arr[i] = arr[j];
                arr[j] = arr[0];
            }
            else
                continue;
        }
    }
    for (i = 1; i <= 10; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

2、直接插入排序 

#include <cstdio>

int main()
{
    int arr[11];
    int i, j;
    for (i = 1; i <= 10; ++i)
        scanf("%d", &arr[i]);
    //0号位置作为哨兵
    //n个元素进行n-1轮 arr[1]不参加
    //第i轮, 在1～i-1寻找插入位置, 从后往前顺序查找
    for (i = 2; i <= 10; i++)
    {
        arr[0] = arr[i];
        for (j = i - 1; j > 0; --j)
        {
            if (arr[j] > arr[0])
            {
                arr[j + 1] = arr[j];
            }
            else
                break;
        }
        arr[j + 1] = arr[0];
    }

    for (i = 1; i <= 10; i++)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

3、归并排序 

#include <cstdio>
#include <algorithm>
/*
    2路归并排序
    2个一组合并，新组内排序
*/
void Connect(int arr[], int L1, int R1, int L2, int R2)
{
    //(L1, R1)和(L2, R2)合并
    int i = L1, j = L2;
    int tmp[(R2 - L2) + (R1 - L1) + 2], index = 0;
    while (i <= R1 && j <= R2)
    {
        if (arr[i] < arr[j])
        {
            tmp[index] = arr[i];
            i++, index++;
        }
        else if (arr[i] > arr[j])
        {
            tmp[index] = arr[j];
            j++, index++;
        }
        else
        {
            tmp[index] = arr[i];
            tmp[index + 1] = arr[j];
            i++, j++, index += 2;
        }
    }
    while (i > R1 && j <= R2)
        tmp[index++] = arr[j++];
    while (i <= R1 && j > R2)
        tmp[index++] = arr[i++];
    //将合并后的序列返回给原arr数组, 还是重新开辟了临时数组
    for (i = 0; i < index; ++i)
        arr[L1 + i] = tmp[i];
}

void MergeSort(int arr[], int left, int right)
{
    if (left < right)
    {
        int middle = (left + right) / 2;
        MergeSort(arr, left, middle);
        MergeSort(arr, middle + 1, right);
        Connect(arr, left, middle, middle + 1, right);
    }
}

int main()
{
    int arr[10] = {2, 5, 9, 3 ,7, 1, 8, 6, 4, 10};
    MergeSort(arr, 0, 9);
    for (int i = 0; i < 10; ++i)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

4、快速排序 

#include <cstdio>
//分割表为左右子表
int Div(int arr[], int begin, int end)
{
    //找到分割位置
    //1、取第一个元素为中心点
    int tmp = arr[begin];
    //2、双指针遍历剩余元素, 比中心点小的往前放, 比中心点大的往后放
    while (begin < end)
    {
        //从后往前找一个<中心点的存入
        while (begin < end && arr[end] >= tmp)
        {
            --end;
        } 
        arr[begin] = arr[end];
        //从前往后找一个>=中心点的存入
        while (begin < end && arr[begin] < tmp)
        {
            ++begin;
        }
        arr[end] = arr[begin];
    }
    //插入中心元素
    arr[begin] = tmp;    
    return begin;
}

//快速排序
void Qsort(int arr[], int begin, int end)
{
    if (begin < end)
    {
        //分割成左右子表
        int middle = Div(arr, begin, end);
        Qsort(arr, begin, middle);
        Qsort(arr, middle + 1, end);
    }
}

int main()
{
    int arr[10] = {2, 4, 1 ,3 ,5 ,8 ,7 ,9 ,6 ,10};
    Qsort(arr, 0, 9);
    for (int i = 0; i < 10; ++i)
        printf("%d ", arr[i]);
    printf("\n");

    return 0;
}

5、随机选择算法 

#include <cstdio>
/*
    时间复杂度O(n) 从无序序列中找到第K大的元素.
    1、进行左右子表分割---确定中心点的位置loc
    2、比较中心点的位置loc ?= K;
       if (loc > K)
          递归(范围:begin ~ loc-1);
       else
          递归(范围:loc+1, end);
*/
//按中心点分割表为左右子表, 并返回中心点的位置
int Div(int arr[], int left, int right)
{
    //1、取首元为中心点
    int tmp = arr[left];
    //2、比中心点小的往前放, 比中心点大的往后放
    while (left < right)
    {
        //从后往前找比中心点小的元素 存入left位置
        while (left < right && arr[right] >= tmp)
            right--;
        arr[left] = arr[right];
        //从前往后找比中心点大的元素 存入right位置
        while (left < right && arr[left] < tmp)
            left++;
        arr[right] = arr[left];
    }
    //left right指针相遇时, 分割完毕， 填入中心点
    arr[left] = tmp;

    return left;
}
//确定第K大的元素
void TheK(int arr[], int left, int right, int K)
{
    int loc = Div(arr, left, right);
    if (loc == K - 1)
    {
        printf("%d\n", arr[loc]);
        return;
    }
    else if (loc > K - 1)
        TheK(arr, left, loc - 1, K);
    else
        TheK(arr, loc + 1, right, K);
}

int main()
{
    int arr[6] = {5, 12, 7, 2, 9, 3};
    TheK(arr, 0, 5, 3);
    TheK(arr, 0, 5, 5);

    return 0;
}

6、堆排序

#include <cstdio>

// 调整单个元素arr[i]
void Adjust(int arr[], int end, int i)
{
    // 该结点与左右孩子相比 2i 2i+1 与其中比较小的交换
    // 直到该结点调整到叶子为止
    // 该结点有几个孩子0 1 2
    if (2 * i > end)
        return;                               // 叶子结点不用调整
    else if (2 * i <= end && 2 * i + 1 > end) // 只有1个孩子
    {
        // 与自己的左孩子比较
        if (arr[i] < arr[2 * i])
            return; // 不用调整, 符合小根堆的要求
        else
        {
            arr[0] = arr[i];
            arr[i] = arr[2 * i];
            arr[2 * i] = arr[0];
            return; // 调整完毕
        }
    }
    else if (2 * i + 1 <= end) // 有2个孩子--不用调整或调整到叶子为止
    {
        if (arr[i] <= arr[2 * i] && arr[i] <= arr[2 * i + 1])
            return; // 不用调整, 符合小根堆的要求
        // 开始调整
        else if (arr[2 * i] > arr[2 * i + 1])
        {
            // 递归回到只有0 1个孩子的情况
            arr[0] = arr[i];
            arr[i] = arr[2 * i + 1];
            arr[2 * i + 1] = arr[0];
            Adjust(arr, end, 2 * i + 1);
        }
        else if (arr[2 * i] < arr[2 * i + 1])
        {
            // 递归回到只有0 1个孩子的情况
            arr[0] = arr[i];
            arr[i] = arr[2 * i];
            arr[2 * i] = arr[0];
            Adjust(arr, end, 2 * i);
        }
    }
}
// 建立堆
void Heap(int arr[], int end)
{
    // 叶子结点天生的满足堆--没有左右孩子
    for (int i = end / 2; i >= 1; --i) // 从最后一个位置(非叶子结点)开始调整
        Adjust(arr, end, i);
}
// 堆排序
void HeapSort(int arr[], int end)
{
    for (int i = 0; i < end - 1; ++i) // n个元素n-1趟排序
    {
        // 前几个元素建立堆
        Heap(arr, end - i);
        // 取出堆顶 --放到最末尾
        arr[0] = arr[1];
        arr[1] = arr[end - i];
        arr[end - i] = arr[0];
    }
}

int main()
{
    // 堆按照完全二叉树展开
    // 取出堆顶元素 重新建立堆(堆调整)
    int arr[9] = {-65535, 4, 3, 1, 2, 6, 8, 5, 7}; // arr[0]弃之不用, 方便按照完全二叉树展开
    int j;
    for (j = 1; j <= 8; ++j)
        printf("%d ", arr[j]);
    printf("\n");
    HeapSort(arr, 8);
    for (j = 1; j <= 8; ++j)
        printf("%d ", arr[j]);
    printf("\n");

    return 0;
}