排序算法:插入排序,折中插入排序,希尔排序,交换排序{冒泡排序,快速排序},选择排序{简单选择，堆排序}

1️⃣插入排序:把序列分为有序和无序两部分排序,如果是升序,则无序和有序比较小则有序右移直到找到大于有序值然后替换,大于则不变，有序++；继续比较；

     主要用途:直接插入算法实现简单，在序列基本有序的情况下，移动和比较的次数少,所以有序情况下优先插入排序

     复杂度与稳定度:属于稳定的排序方法,时间复杂度 O(n^2) 空间复杂度 O(1);

C/C++:

#include <iostream>

int *InsertSort(int *Array, int size)
{
    if (Array == nullptr)
        return nullptr;

    //思想分为有序和无序部分
    int unorder = 0, order = 0, temp;

    for (unorder = 1; unorder < size; unorder++)
    {
        //保存比较的值
        temp = *(Array + unorder);
        for (order = unorder - 1; order >= 0 && temp < *(Array + order); order--)
        {
            //升序,无序值小于有序值则有序值右移,直到找到比有序小的或order==0;
            *(Array + order + 1) = *(Array + order);
        }
        //不移动则赋值给自身，或者找到插入位置，赋值插入位置后的位置;
        *(Array + order + 1) = temp;
    }
    return Array;
}


int main()
{

    int a[] = {17, 46, 32, 87, 58, 9, 50, 38};
    int size = sizeof(a) / sizeof(int);
    InsertSort(a, size);

    std::for_each(std::begin(a), std::end(a), [](int &value)
    { std::cout << value << "	"; });
    std::cout << std::endl;
    return 0;
}

2️⃣折中插入排序:与插入排序的区别,寻找插入位置由从右到左遍历比较变为二分法查找比较(减少比较次数)

     主要用途:同插入排序

     复杂度与稳定度:同插入排序(虽然比较次数少了)

C/C++:

#include <iostream>


//折中插入排序,和插入排序的区别就是改变 无序在有序中查找位置的方式，前者是折中查找(减少比较次数),后者是从右到左遍历比较
int *HalfInsertSort(int *Array, int size)
{
    if (Array == nullptr)
        return nullptr;

    //思想分为有序和无序部分
    int unorder = 0, order = 0, temp;

    //计算机中两数之和除以2取整之后值靠左(个人理解),(low+hight)/2 最终位置保存在low位置;
    int low = 0, hight = 0, mid = 0;

    for (unorder = 1; unorder < size; unorder++)
    {
        //保存比较的值
        temp = *(Array + unorder);

        //寻找位置,终止条件位置出现负值之前- -,(升序)
        for (low = 0, hight = unorder - 1; hight >= low;)
        {
            mid = (low + hight) / 2;
            if (temp < *(Array + mid))
            {
                hight = mid - 1;
            } else
            {
                low = mid + 1;
            }
        }

        //找到插入点low,移动
        for (order = unorder - 1; order >= low; order--)
        {
            //升序,无序值小于有序值则有序值右移,直到找到比有序小的或order==0;
            *(Array + order + 1) = *(Array + order);
        }

        *(Array + low) = temp;
    }
    return Array;
}


int main()
{

    int a[] = {17, 2, 3, 5, 4, 4, 34, 43, 323, 434, 234, 21, 46, 32, 87, 58, 9, 50, 38};
    int size = sizeof(a) / sizeof(int);
    InsertSort(a, size);

    std::for_each(std::begin(a), std::end(a), [](int &value)
    { std::cout << value << "	"; });
    std::cout << std::endl;
    return 0;
}

3️⃣希尔排序:是插入排序的改版，因为之前提到插入排序如果在序列有一定有序的情况比较次数会很少，所以希尔排序就是为增量为1的插入排序提供基本有序序列,

     具体操作:先设定增量(一般序列size/2)，例如10，增量规律5,2,1，然后根据增量间隔把序列分成增量个序列(如果按/2分增量，原数列是奇数序列的话会少选中一

     个数,偶数列则 每个数都有归属分配的小数列,增量为1时肯定就都分配到了- -(以上只是个人blalala));

     复杂度与稳定度:希尔排序是一种非稳定排序,由于增量是随机的，分析时间复杂度就比较困难当增量序列delta[k]=2^t-k+1 (其中,t为排序次数 1<=k<=t<<(以2为底n+1的对数)),

     时间复杂度O(n^3/2)，空间复杂度O(1);

C/C++:

#include <iostream>


//希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，
//是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因DL．Shell于1959年提出而得名。


int *shellsort(int *Array, int size)
{
    int gap_value = 0;
    //外层循环控制增量以把序列分组
    for (gap_value = size / 2; gap_value > 0; gap_value /= 2)
    {
        //内层嵌套循环执行[直接插入算法],只是序列根据增量选择
        for (int unorde = gap_value; unorde < size; unorde++)//根据增量与序列长度 得当前增量下序列数
        {
            //实际直接插入比较,原来是右移查找，这里是交换停止来查找插入位置..
            for (int order = unorde - gap_value;
                 order >= 0 && *(Array + order) > *(Array + order + gap_value); order -= gap_value)
            {
                //交换(突然想换异或交换- -，纯粹fun)
                *(Array + order) = *(Array + order + gap_value) ^ *(Array + order);
                *(Array + order + gap_value) = *(Array + order) ^ *(Array + order + gap_value);
                *(Array + order) = *(Array + order) ^ *(Array + order + gap_value);
            }
        }
    }

    return Array;

}

int main()
{
    int s[] = {1,2,3,4,5,6};

    shellsort(s, sizeof(s) / sizeof(int));

    for (int i = 0; i < sizeof(s) / sizeof(int); i++)
    {
        std::cout << s[i] << " ";
    }

    return 0;
}

4️⃣冒泡排序:冒泡算法实现简单，适用排序元素较少，时间要求度不高的场合

     复杂度和稳定度:冒泡排序是一种稳定的排序方式,时间复杂度0(n^2),空间复杂度0(1)

     代码实例:代码中写了冒泡排序，双向冒泡排序,测试之后双向冒泡更快

C/C++:

#include <iostream>

//冒泡算法实现简单，适用于排序元素较少，时间要求度不高的场合
//复杂度与稳定度: 冒泡排序是一种稳定的排序方法,时间复杂度0(n^2)，空间复杂度0(1)


void display(int* Array,int size);

int *BobolingSort(int *Array, int size)
{
    if (Array == nullptr)
        return nullptr;
    int temp = 0;
    for (int n = 1; n < size; n++)
    {
        for (int j = 0; j < size - n; j++)
        {
            if (*(Array + j + 1) < *(Array + j))
            {
                temp = *(Array + j + 1);
                *(Array + j + 1) = *(Array + j);
                *(Array + j) = temp;
            }
        }
    }

    return Array;
}



int *DoubleBobolingSorot(int *Array, int size)
{
    if (Array == nullptr)
        return nullptr;

    int i=0;
    int low = 0, hight = size - 1;     //正向遍历起点low，方向遍历起点hight
    bool flag = true;   //标志序列是否还有逆序
    int temp = 0;
    while (low < hight && flag)
    {
        flag = false;      //设置0
        for (i= low; i < hight; i++)          //正向遍历
        {
            if (*(Array + i) > *(Array + i + 1))
            {
                temp = *(Array + i);
                *(Array + i) = *(Array + i + 1);
                *(Array + i + 1) = temp;
                flag = true;        //有交换则true
            }
        }
        hight--;      //更新上界


        for (i = hight; i > low; i--)
        {
            if (*(Array + i) < *(Array + i - 1))
            {
                temp = *(Array + i);
                *(Array + i) = *(Array + i - 1);
                *(Array + i - 1) = temp;
                flag = true;
            }
        }

        low++;        //更新下界

    }

    return Array;
}

void display(int* Array,int size)
{
    for(int i=0;i<size;i++)
    {
        std::cout<<*(Array+i)<<"	";
    }
    std::cout<<std::endl;
}


int main()
{

    std::clock_t start=0,end=0;


    int test1[]={22,3364,23,44,32,66,45,666,88,88,23,4,5,6};
    int test2[]={22,3364,23,44,32,66,45,666,88,88,23,4,5,6};


    start=clock();
    for(int i=0;i<100000000;i++)
    {
        BobolingSort(test1, sizeof(test1)/ sizeof(int));
    }
    end=clock();
    std::cout<<"Simple Bob runtime: "<<((double)(end-start)/CLOCKS_PER_SEC)<<std::endl;

    std::cout<<"序列1: ";
    display(test1,sizeof(test1)/ sizeof(int));


    start=clock();
    for(int i=0;i<100000000;i++)
    {
        DoubleBobolingSorot(test2, sizeof(test2)/ sizeof(int));
    }
    end=clock();
    std::cout<<"Double Bob runtime: "<<((double)(end-start)/CLOCKS_PER_SEC)<<std::endl;

    std::cout<<"序列2: ";
    display(test2,sizeof(test1)/ sizeof(int));


    return 0;
}

5️⃣快速排序:是冒泡排序的改进，也属于交换类排序，原理:①假设元素有N个，则选取第一个元素为枢轴pivot=Array[0],且low=0,hight=sizof(Array)/sizeof(int),

                    用i位置的pivot与hight比较，不小于则hight--向左推进，否则交换，从low++开始于pivot比较，大于则交换，hight--；否则推进，这样就完成

                    第一趟排序，小于pivot的在左边，大于的在右边,然后根据pivot的位置分成2序列，依照这个规律继续比较交换，直到low>=hight时则完成,

                    主要利用递归比较好运算(可是博主认为- -，这影响了效率);

    复杂度与稳定度:是一种不稳定的排序方式,时间复杂度最坏0(n^2),平均时间复杂度0(nlogn),空间复杂度0(logn);

                   代码实例:与冒泡排序，双向冒泡排序，快速排序，运行时间比较同一序列排列1*10^7次数下的运行时间，双向运算比较快速- -，可能博主快排实现              太慢(导致运行速率慢);

#include <iostream>


//快速排序

void display(int* Array,int size)
{
    for(int i=0;i<size;i++)
    {
        std::cout<<*(Array+i)<<"	";
    }

    std::cout<<std::endl;
}





//实现一趟排序并返回pivot位置
int QuickSort(int *Array, int low, int hight)
{
    int pivot = *(Array + low);;
    int teamp = *(Array + low);

    while (low < hight)
    {
        //相对pivot从右往左寻找小于pivot的
        while (low < hight && *(Array + hight) >=pivot)
            hight--;

        if (low < hight)
        {
            *(Array + low) = *(Array + hight);
            low++;
        }

        while (low < hight && *(Array + low) <=pivot)
            low++;

        if (low < hight)
        {
            *(Array + hight) = *(Array + low);
            hight--;
        }

        *(Array + low) = teamp;
    }



    return low;
}

void RecursiveQuickSort(int *Array, int low, int hight)
{
    int pivot;

    if (low < hight)
    {
        pivot = QuickSort(Array, low, hight);
        RecursiveQuickSort(Array, low, pivot - 1);
        RecursiveQuickSort(Array, pivot + 1, hight);
    }

}




int main()
{

    std::clock_t start=0,end=0;


    int test1[]={22,3364,23,44,32,66,45,666,88,88,23,4,5,6};


    start=clock();
    for(int i=0;i<10000000;i++)
    {
        RecursiveQuickSort(test1,0,(sizeof(test1)/ sizeof(int)-1));
    }
    end=clock();
    std::cout<<"RecursiveQuickSort runtime: "<<((double)(end-start)/CLOCKS_PER_SEC)<<std::endl;

    std::cout<<"序列2: ";
    display(test1,sizeof(test1)/ sizeof(int));
    return 0;
}

C/C++:三种排序方法运行时间比较

#include <iostream>


//快速排序

void display(int* Array,int size)
{
    for(int i=0;i<size;i++)
    {
        std::cout<<*(Array+i)<<"	";
    }

    std::cout<<std::endl;
}


int *BobolingSort(int *Array, int size)
{

    if (Array == nullptr)
        return nullptr;
    int temp = 0;
    for (int n = 1; n < size; n++)
    {
        for (int j = 0; j < size - n; j++)
        {
            if (*(Array + j + 1) < *(Array + j))
            {
                temp = *(Array + j + 1);
                *(Array + j + 1) = *(Array + j);
                *(Array + j) = temp;
            }
        }
    }

    return Array;
}


//实现一趟排序并返回pivot位置
int QuickSort(int *Array, int low, int hight)
{
    int pivot = *(Array + low);;
    int teamp = *(Array + low);

    while (low < hight)
    {
        //相对pivot从右往左寻找小于pivot的
        while (low < hight && *(Array + hight) >=pivot)
            hight--;

        if (low < hight)
        {
            *(Array + low) = *(Array + hight);
            low++;
        }

        while (low < hight && *(Array + low) <=pivot)
            low++;

        if (low < hight)
        {
            *(Array + hight) = *(Array + low);
            hight--;
        }

        *(Array + low) = teamp;
    }



    return low;
}

void RecursiveQuickSort(int *Array, int low, int hight)
{
    int pivot;

    if (low < hight)
    {
        pivot = QuickSort(Array, low, hight);
        RecursiveQuickSort(Array, low, pivot - 1);
        RecursiveQuickSort(Array, pivot + 1, hight);
    }

}

int *DoubleBobolingSorot(int *Array, int size)
{
    if (Array == nullptr)
        return nullptr;

    int i=0;
    int low = 0, hight = size - 1;     //正向遍历起点low，方向遍历起点hight
    bool flag = true;   //标志序列是否还有逆序
    int temp = 0;
    while (low < hight && flag)
    {
        flag = false;      //设置0
        for (i= low; i < hight; i++)          //正向遍历
        {
            if (*(Array + i) > *(Array + i + 1))
            {
                temp = *(Array + i);
                *(Array + i) = *(Array + i + 1);
                *(Array + i + 1) = temp;
                flag = true;        //有交换则true
            }
        }
        hight--;      //更新上界


        for (i = hight; i > low; i--)
        {
            if (*(Array + i) < *(Array + i - 1))
            {
                temp = *(Array + i);
                *(Array + i) = *(Array + i - 1);
                *(Array + i - 1) = temp;
                flag = true;
            }
        }

        low++;        //更新下界

    }

    return Array;
}



int main()
{

    std::clock_t start=0,end=0;


    int test1[]={22,3364,23,44,32,66,45,666,88,88,23,4,5,6};
    int test2[]={22,3364,23,44,32,66,45,666,88,88,23,4,5,6};
    int test3[]={22,3364,23,44,32,66,45,666,88,88,23,4,5,6};


    start=clock();
    for(int i=0;i<10000000;i++)
    {
        BobolingSort(test3,(sizeof(test3)/ sizeof(int)));
    }
    end=clock();
    std::cout<<"Simple Bob runtime: "<<((double)(end-start)/CLOCKS_PER_SEC)<<std::endl;

    std::cout<<"序列0: ";
    display(test3,sizeof(test3)/ sizeof(int));


    start=clock();
    for(int i=0;i<10000000;i++)
    {
        DoubleBobolingSorot(test1, sizeof(test1)/ sizeof(int));
    }
    end=clock();
    std::cout<<"Double Bob runtime: "<<((double)(end-start)/CLOCKS_PER_SEC)<<std::endl;

    std::cout<<"序列1: ";
    display(test1,sizeof(test1)/ sizeof(int));


    start=clock();
    for(int i=0;i<10000000;i++)
    {
        RecursiveQuickSort(test2,0,(sizeof(test2)/ sizeof(int)-1));
    }
    end=clock();
    std::cout<<"RecursiveQuickSort runtime: "<<((double)(end-start)/CLOCKS_PER_SEC)<<std::endl;

    std::cout<<"序列2: ";
    display(test2,sizeof(test1)/ sizeof(int));
    return 0;
}

5.简单选择排序:是一种不稳定的排序方法，通过递归找到最小或者最大元素位置，并与首元素交换，这样，完成第一趟排序，之后亦然，index相同则不交换，总需要元素数n-1趟排序，比较次数不定(查到的是需要3(n-1)/2次比较，可是我认为这应该是不确定的啊)，最多3(n-1)次移动数值,而最好呈有序则不需排序，最坏都要排序

复杂度与稳定度:不稳定排序,时间复杂度O(n^2),空间复杂度O(1)

C/C++代码:

#include <iostream>


int *
selectsort(int *Array, std::size_t size)
{
    if (Array == nullptr)
    {
        return nullptr;
    }

    std::size_t index = 0;

    for (int i = 0; i < size; i++)
    {
        index = i;

        for (int j = i+1; j < size; j++)
        {
            if (*(Array + index) > *(Array + j))
            {
                index = j;
            }
        }

        if (index != i)
        {
            std::swap(*(Array + index), *(Array + i));
        }

    }

    return Array;
}


void
display(int *Array, int size)
{
    for (int i = 0; i < size; i++)
    {
        std::cout << *(Array + i) << "	";
    }

    std::cout << std::endl;
}


int
main(int argc, char **argv)
{


    int test1[] = {22, 3364, 23, 44, 32, 66, 45, 666, 88, 88, 23, 4, 5, 6};

    selectsort(test1, sizeof(test1) / sizeof(int));
    display(test1, sizeof(test1) / sizeof(int));
    return 0;
}

 6.堆排序:选择排序的改进版本(各种改进qwq), 概念上的二叉树，实际操作的是数组,利用二叉树的思维创造数组树，根据规则每个元素a[i]可以有lnode=a[2*i+1],rnode=

a[2*i+2]这样的约束，分为两部分，初始化大/小顶堆，调整大/小顶堆,而 初始化大/小顶堆操作 依赖 调整大/小顶堆操作，初始化大/小顶堆需要从最后一个非叶子结点开始，根据约束向上创建顶堆，得出第一个最大/最小元素，之后可以pop最大或最小元素(例子中，是替换尾部元素)，从尾部填充根节点，缩小范围从0~尾部向下调整顶堆，使新极值替换到根节点- -，大概这样

时间复杂度和空间复杂度:时间复杂度O(nlogn^2),空间上 O(1);

C/C++代码:

#include <iostream>
#include <iomanip>


void
adjustheap(int *, std::size_t, std::size_t);

void
createheap(int *Array, std::size_t length)
{
    if (Array == nullptr)
    {
        return;
    }


    //建立大顶堆
    //先从第一个非叶子结点开始，向上建立堆
    for (int i = length / 2 - 1; i >= 0; --i)
    {
        adjustheap(Array, i, length - 1);
    }


}

//调整大顶堆
void
adjustheap(int *Array, std::size_t node_p, std::size_t length)
{
    if (Array == nullptr)
    {
        return;
    }

    //保存当前根节点值
    int t = *(Array + node_p);

    for (int i = 2 * node_p + 1; i <=length; i = i * 2 + 1)
    {
        //先判别左右子节点大小，确定与根节点比较对象,小于则更i++
        if (i < length && (*(Array + i) < *(Array + i + 1)))
        {
            i++;
        }


        //与当前根节点比较
        if (t > *(Array + i))
        {
            break;
        }

        //小于则交换
        *(Array + node_p) = *(Array + i);
        node_p = i;
        //保存交换过的位置，为了向下寻找是否还有小于 根节点值得节点以让根节点赋值
    }

    *(Array + node_p) = t;

}

void
display(int *Array, std::size_t length)
{

    if (Array == nullptr)
    {
        return;
    }


    for (int i = 0; i < length; i++)
    {
        std::cout << Array[i] << std::setw(4);
    }

    std::cout << std::endl;

}


void
sortheap(int *Array, std::size_t length)
{
    if (Array == nullptr)
    {
        return;
    }
    createheap(Array, length);

    std::cout << "初始化大顶堆: ";
    display(Array, length);

    //循环把大顶堆根节点与尾节点交换
    for (int i = 1; i <length; i++)
    {
        int temp = Array[0];
        Array[0] = Array[length - i];
        Array[length - i] = temp;


        std::cout << "  第" << i << "趟排序: ";
        display(Array, length);

        //之后缩小范围调整新大顶堆,因为顶对已经保持a[i]>=a[2*i+1]&&a[2*i+2] 性质，可从0~未替换尾部元素之间检查顶堆规则
        adjustheap(Array, 0, length - i-1);
    }


}


int
main(int argc, char **argv)
{
    int test[] = {4, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    sortheap(test, sizeof(test) / sizeof(test[0]));

    return 0;
}