Blue is white,dark is not blue(常用排序算法)

#include <iostream>
// blue is white,dark is not blue
using namespace std;
void swap(int *,int *);
void print(int *,int);
void bubbleSort(int *,int); // 稳定
void selectSort(int *,int);// 不稳定
void insertSort(int *,int);// 稳定
void bucketSort();
void mergeSort(int *,int);// 稳定
void shellSort(int *,int);// 不稳定
void quickSort(int *,int);// 不稳定
void heapSort(int *,int);// 不稳定

int main()
{
    //bucketSort();
    int arr[] = {-200,2,39,89,0,4,-155,9,333,2,4,55,66,656,767,878,6454,76,-2000};
    int size = sizeof(arr) / 4;
    heapSort(arr,size);
    print(arr,size);
    return 0;
}

void swap(int *a,int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void print(int * arr,int size)
{
    for(int i = 0; i < size; ++i)
    {
        cout << arr[i] << ends;
    }
    cout << endl;
}
void bubbleSort(int *arr,int size)
{
    for(int i = 0; i < size; ++i)
    {
        int isSwitch = 0; // 如果一趟比较没有交换位置 说明后续元素时正确的 则不用进行比较了
        int isFromStart = 0;
        if(isFromStart) // 先放前面 则每次从最后一个开始 且终止位置变化
        {
            for(int j = size - 1; j > i; --j)
            {
                if(arr[j] < arr[j - 1])
                {
                    swap(&arr[j],&arr[j - 1]);
                    isSwitch = 1;
                }
            }
        }
        else //先放后面 则每次从第一个开始比较 终止位置递减
        {
            for(int j = 0; j < size - i - 1; ++j)
            {
                if(arr[j] > arr[j + 1])
                {
                    swap(&arr[j],&arr[j+1]);
                    isSwitch = 1;
                }
            }
        }

        if(!isSwitch)
        {
            break;
        }
    }
    cout << __func__ << endl;

}

void selectSort(int *arr,int size)
{
    for(int i = 0; i < size; ++i)
    {
        int isFromStart = 1; //是否从开始位置归位
        //先把前面放好 因为冒泡每趟停止时是该元素的定位
        //所以冒泡开始的方向总是和放好的方向是相反的 而选择是下标传递 最后进行交换
        //也就是说你经过一趟选择排序之后 你拿到了一个最大/最小值 最后和他交换位置的地方由你定
        if(isFromStart)
        {
            int guardIndex = i;
            for(int j = i + 1; j < size; ++j)
            {
                if(arr[guardIndex] > arr[j])
                {
                    guardIndex = j;
                }
            }
            if(guardIndex != i)
            {
                swap(&arr[guardIndex],&arr[i]);
            }
        }
        else //先把后面放好
        {
            int guardIndex = 0;
            for(int j = 1; j < size - i; ++j)
            {
                if(arr[guardIndex] < arr[j])
                {
                    guardIndex = j;
                }
            }
            swap(&arr[guardIndex],&arr[size - i - 1]);
        }

    }
    cout << __func__ << endl;

}


void bucketSort() //同排序是根据元素当下标进行排序的 所以适合数据值不大的自然数排序
{
    int arr[] = {3,3,1,2,2,10,5};
    int book[11] = {0};

    for(unsigned int i = 0; i < sizeof(arr) / 4u; ++i)
    {
        book[arr[i]]++;
    }
    int i = 0;
    while(i < 11)
    {
        while(book[i]-- > 0)
        {
            cout << i << ends;
        }
        ++i;
    }
}

void internalMerge(int *arr,int l,int c,int r,int *temp)
{
    int i = l;
    int j = c + 1;
    int k = l;
    while(i <= c && j <= r)
    {
        if(arr[i] <= arr[j])
        {
            temp[k] = arr[i];

            ++i;
        }
        else
        {
            temp[k] = arr[j];

            ++j;
        }
        ++k;
    }
    if(i > c)
    {
        while(j <= r)
        {
            temp[k] = arr[j];
            ++j;
            ++k;
        }
    }

    if(j > r)
    {
        while(i <= c)
        {
            temp[k] = arr[i];
            ++i;
            ++k;
        }
    }

    for(int i = l; i <= r; ++i)
    {
        arr[i] = temp[i];
    }
}

void internalMergeSort(int *arr,int l,int c,int r,int *temp)
{
    if(l == r)
    {
        return;
    }
    else
    {
        internalMergeSort(arr,l,(l + c) / 2,c,temp);
        internalMergeSort(arr,c + 1,(c + 1 + r) / 2,r,temp);
        internalMerge(arr,l,c,r,temp);
        return;
    }

}


//归并排序是分治思想的提现 先让左边有序 再让右边有序 最后将两个有序的序列合并成一个有序的

void mergeSort(int *arr,int size)
{
    int temp[size];
    int left = 0;
    int center = size / 2;
    int right = size - 1;
    internalMergeSort(arr,left,center,right,temp);
    for(int i = 0; i < size; ++i)
    {
        arr[i] = temp[i];
    }
    cout << __func__ << endl;
}

void insertSort(int * arr,int size) //抓牌排序 每次抓取一张 放入已经排序的合适位置 伴随着一些元素的后移
{
    for(int i = 1; i < size; ++i)
    {
        int guardIndex = i; //抓牌
        while(guardIndex >= 1 &&arr[guardIndex] < arr[guardIndex - 1]) //如果无需移动 直接进入下次抓牌
        {
            swap(&arr[guardIndex],&arr[guardIndex - 1]);
            --guardIndex;
        }
    }
    cout << __func__ << endl;

}

//通过希尔序列 进行简单排序
void shellSort(int *arr,int size)
{
    for (int shellKey = size / 2; shellKey > 0; shellKey /= 2)
    {
        for(int i = shellKey; i < size; i += shellKey)
        {
            int guardIndex = i;
            while((guardIndex >= shellKey && arr[guardIndex] < arr[guardIndex - shellKey]) )
            {
                swap(&arr[guardIndex],&arr[guardIndex - shellKey]);
                guardIndex -= shellKey;
            }
        }

    }
    cout << __func__ << endl;
}

int internalGetIndex(int *arr,int left,int center,int right)
{
    if(arr[left] > arr[center])
    {
        if(arr[left] > arr[right])
        {
            return left;
        }
        else
        {
            return right;
        }
    }
    else
    {
        if(arr[center] > arr[right])
        {
            return center;
        }
        else
        {
            return right;
        }
    }
}

void internalQuickSort(int *arr,int left,int right)
{
    if(left >= right)
    {
        return;
    }
    int baseIndex = internalGetIndex(arr,left,(left + right) / 2,right);
    swap(&arr[left],&arr[baseIndex]);
    int baseValue = arr[left];
    int guardLeft = left + 1;
    int guardRight = right;
    while(guardLeft < guardRight)
    {
        while(arr[guardLeft] < baseValue)
        {
            ++guardLeft;
        }
        while(arr[guardRight] > baseValue)
        {
            --guardRight;
        }
        if(guardLeft < guardRight)
        {
            swap(&arr[guardLeft],&arr[guardRight]);
        }

    }
    swap(&arr[left],&arr[guardRight]);
    internalQuickSort(arr,left,guardRight - 1);
    internalQuickSort(arr,guardRight + 1,right);
}

void quickSort(int *arr,int size)
{
    internalQuickSort(arr,0,size - 1);
    cout << __func__ << endl;
}


struct MiniHeap
{
    int *arr = new int[10]();
    int capacity = 10;
    int size = 0;
    void resize()
    {
        int *temp = arr;
        arr = new int[capacity * 2]();
        for(int i = 1; i <= size; ++i)
        {
            arr[i] = temp[i];
        }
        delete temp;
        capacity = capacity * 2;
    }
    void push(int a)
    {
        if(size + 1== capacity)
        {
            resize();
        }
        if(size == 0)
        {
            arr[1] = a;
        }
        else
        {
            int guardIndex = size + 1;
            while(guardIndex > 1 && a < arr[guardIndex / 2]) //自底向上比较
            {
                arr[guardIndex] = arr[guardIndex / 2];
                guardIndex = guardIndex / 2;
            }
            arr[guardIndex] = a;
        }

        ++size;

    }

    int pop()
    {
        int result = arr[1];
        int guard = arr[size];
        int guardIndex = 1;
        //当存在左右孩子任意一个时 且 其中有一个孩子的值大于它时
        while((guardIndex * 2 < size || guardIndex * 2 + 1 < size) && (guard > arr[guardIndex * 2] || guard > arr[guardIndex * 2 + 1]))
        {

            if(arr[guardIndex * 2] < arr[guardIndex * 2 + 1]) //和左边的进行交换
            {
                arr[guardIndex] = arr[guardIndex * 2];
                guardIndex *= 2;
            }
            else //和右边的进行交换
            {
                arr[guardIndex] = arr[guardIndex * 2 + 1]; //将右孩子的值移到当前索引
                guardIndex = 2 * guardIndex + 1; //将目标索引移动右孩子
            }
        }
        arr[guardIndex] = guard; // 末尾元素归位
        --size;
        return result;
    }

};

//堆排序通过构建最大堆最小堆进行
//添加是元素放入数组最后 然后自底向上和他比较 取元素时直接返回数组第一个即使最大最小值 在进行自顶向下调节
void heapSort(int *arr,int size)
{
    MiniHeap miniHeap;
    for(int i = 0; i < size; ++i)
    {
        miniHeap.push(arr[i]);
    }
    for(int i = 0; i < size; ++i)
    {
        arr[i] = miniHeap.pop();
    }
    cout << __func__ << endl;
}