【数据结构与算法】基础排序

维他命C++

已于 2022-03-17 18:36:01 修改

阅读量1.8k

点赞数 1

分类专栏：数据结构与算法文章标签：排序算法算法数据结构

于 2022-03-12 21:03:50 首次发布

本文链接：https://blog.csdn.net/weixin_61901599/article/details/123450061

版权

数据结构与算法专栏收录该内容

6 篇文章 1 订阅

订阅专栏

一二分查找

一实例

template<typename Type>
int Binary_Search(Type* arr, int size, Type target)
{
    Type* myArr = Insert_Sort(arr, size);
    int right = size -1, left = 0, mid = 0;
    while (left <= right)
    {
        mid = left +((right - left) >> 1);
        if (arr[mid] = target)
            return mid + 1;
        if (arr[mid] > target)
            right = mid - 1;
        else
            left = mid + 1;
    }
    return -1;
}

二冒泡与快速

一冒泡排序

template<typename Type>
void Bubble_Sort(Type arr[], int size)
{
    Type temp;
    int j;
    for (int i = 0; i < size - 1; ++i)
    {
        for (j = 0; j < size - i - 1; ++j)
        {
            if (arr[j] < arr[j + 1])
            {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

二快速排序

template<typename Type>
void LoopBody(Type* arr, int Left, int Right);
template<typename Type>
void Quick_Down(Type* arr, int size)
{
    LoopBody(arr, 0, size - 1);
}
template<typename Type>
void LoopBody(Type* arr, int Left, int Right)
{
    //1 标杆
    Type mark = arr[Right];
    //2 游标
    int left = Left;
    int right = Right - 1;
    //3 结束条件
    if (Left >= Right)
        return;
    //4 划分左右区间
    Type temp;
    while (left <= right)
    {
        while (left <= right && arr[left] >= mark)
        {
            ++left;
        }
        while (left <= right && arr[right] <= mark)
        {
            --right;
        }
        if (left < right)
        {
            temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }
    //5 标杆归位
    arr[Right] = arr[left];
    arr[left] = mark;
    //6 递归左右区间
    LoopBody(arr, left + 1, Right);
    LoopBody(arr, Left, left - 1);
}

三插入与希尔

一插入排序

template<typename Type>
void Insert_Sort(Type arr[], int size)
{
    for (int i = 1; i < size; i++)
    {
        int j = i - 1;
        int temp = arr[i];
        for (; j >= 0; --j)
        {
            if (arr[j] > temp)
            {
                arr[j + 1] = arr[j];
            }
            else
            {
                break;
            }
        }
        arr[j + 1] = temp;
    }
}


二 希尔排序
//初级希尔排序
template<typename Type>
void Shell_Sort(Type arr[], int size)
{
    int jump = size >> 1;
    int temp, j;
    while (jump)
    {
        for (int i = jump; i < size; i++)
        {
            int j = i - jump;
            int temp = arr[i];
            for (; j >= 0; j -= jump)
            {
                if (arr[j] > temp)
                {
                    arr[j + jump] = arr[j];
                }
                else
                {
                    break;
                }
            }
            arr[j + jump] = temp;
        }
        jump >>= 1;
    }
}
//终极希尔排序
template<typename Type>
void Super_Shell(Type arr[], int size)
{
    int jump = size >> 1;
    int temp, j;
    while (jump)
    {
        for (int i = jump; i < size; ++i)
        {
            temp = arr[i];
            j = i - jump;
            for (; j >= 0 && arr[j] > temp; )
            {
                arr[j + jump] = arr[j];
                j = j - jump;
            }
            arr[j + jump] = temp;
        }
        jump = jump >> 1;
    }
}




四 基数排序
#define N 13
template<typename Type>
void Radix_Sort(Type* arr, int size)
{
    int temp[10][N] = {};
    int i, j, k;
    int index = 0;
    for (int n = 1; n < 10000; n *= 10)
    {
        for (i = 0; i < 10; i++)
        {
            for (j = 0; j < N; j++)
            {
                temp[i][j] = -1;
            }
        }
        for (j = 0; j < size; j++)
        {
            index = (arr[j] / n) % 10;
            temp[index][j] = arr[j];
        }
        k = 0;
        for (i = 0; i < 10; ++i)
        {
            for (j = 0; j < N; ++j)
            {
                if (temp[i][j] != -1)
                {
                    arr[k++] = temp[i][j];
                }
            }
        }
    }
}

五归并排序

一思维导图

二实例

void Two_Merger(int arr[], int left, int mid, int right);
void _merge(int arr[], int left, int right);
void Merge_Sort(int arr[], int len)
{
    _merge(arr, 0, len - 1);
}
void _merge(int arr[], int left, int right)
{
    // 递归结束条件
    if (left >= right)
        return;

    int mid = ((right - left) >> 1) + left;
    //递归左右区间
    _merge(arr, left, mid);
    _merge(arr, mid + 1, right);
    //二路归并
    Two_Merger(arr, left, mid, right);
}
void Two_Merger(int arr[], int left, int mid, int right)
{
    //辅助数组
    int length = right - left + 1;
    int* pTemp = new int[length];
    //游标
    int down = left;
    int up = mid + 1;
    int index = 0;

    while (down <= mid && up <= right)
    {
        //左区间的元素比右区间的小 落下
        while (down <= mid && arr[down] <= arr[up])
        {
            pTemp[index] = arr[down];
            index++;
            down++;
        }
        //右区间的元素比左区间的小 落下
        while (up <= right && arr[down] > arr[up])
        {
            pTemp[index] = arr[up];
            index++;
            up++;
        }
    }
    //
    if (down <= mid)
    {
        memmove(&pTemp[index], &arr[down], sizeof(int)*(mid - down + 1));
    }
    if (up <= right)
    {
        memmove(&pTemp[index], &arr[up], sizeof(int)*(right - up + 1));
    }
    //接手辅助的数据
    memmove(&arr[left], pTemp, sizeof(int)*length);
    //释放
    delete[]pTemp;
}

四选择排序

template<typename Type>
void Select_Sort(Type arr[], int size)
{
    int temp;
    int j;
    for (int i = size - 1; i > 0; --i)
    {
        for (j = i - 1; j >= 0; --j)
        {
            if (arr[i] > arr[j])
            {
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
}