排序算法汇总

Posted 2020-12-24 xiehuan-blog

//冒泡排序
void bubbleSort(int arr[],int len){
    //相邻两个元素进行比较 把大的放后面小的放前面  一个完整的比较之后，最大值放在末尾
    for(int i=1;i<len;i++){//冒泡的次数
        //第i次冒泡，把当前最大值放到  len-i
        //从0冒泡到len-i
        bool flag = false;
        for(int j=1;j<=len-i;j++){
            if(arr[j]<arr[j-1]){
                int tmp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = tmp;
                flag = true;//表示该次完整的循环有交换位置
            }
        }
        if(flag == false){//所有的相邻元素都已经有序，代表整个数组有序，不需要再进行排序
            break;    
        }
    }
}
//选择排序
void selectSort(int arr[],int len){
    for(int i=1;i<len;i++){//总共要找len-1次最大值
        //每次找最大值的区间 [0,len-i]
        int pos = 0;
        for(int j=1;j<=len-i;j++){//因为假设了0下标就是最大值，所以循环可以从1开始
            if(arr[j] > arr[pos]){
                pos = j;
            }
        }
        if(pos != len-i){
            int tmp = arr[pos];
            arr[pos] = arr[len-i];
            arr[len-i] = tmp;
        }
    }    
}
//鸡尾酒排序   选择排序一种变化形式
void cookTailSort(int arr[],int len){
    for(int i=1;i<=len/2;i++){
        int max = i-1;
        int min = i-1;
        //[i-1,len-i]
        for(int j=i;j<=len-i;j++){
            if(arr[j] > arr[max]){
                max = j;
            }
            if(arr[j] < arr[min]){
                min = j;    
            }
        }
        if(max != len-i){
            int tmp = arr[len-i];
            arr[len-i] = arr[max];
            arr[max] = tmp;
        }
        if(min == len-i){//最小值的位置正好在本来应该存储最大值位置 经过上面交换之后最小值放到了max位置上
            int tmp = arr[i-1];
            arr[i-1] = arr[max];
            arr[max] = tmp;
        }else if(min != i-1){
            int tmp = arr[i-1];
            arr[i-1] = arr[min];
            arr[min] = tmp;
        }
    }    
}


//插入排序 直接插入
void insertSort(int arr[],int len)
{
    //把下标为i的这个元素插入到前面 前面数组是有序
    for(int i=1;i<len;i++)
    {
        //记录要插入的值  往后移的过程会覆盖arr[i]的值 提前保存
        int num = arr[i];
        //循环比较
        int j = 0;
        //for(j=i-1;j>=0&&num<arr[j];j--){arr[j+1] = arr[j];}
        //如果不执行break  j==-1
        for(j=i-1;j>=0;j--)
        {
            if(num < arr[j])
            {
                arr[j+1] = arr[j];//把数据往后移
            }
            else//arr[j] >= num   插入的位置j+1
            {
                break;    
            }
        }
        if(j != i-1)
        {
            arr[j+1] = num;    
        }
    }
}

//插入排序   折半插入  二分插入
void binaryInsertSort(int arr[],int len)
{
    for(int i=1;i<len;i++)
    {
        int num = arr[i];
        int left = 0;//左区间
        int rigth = i-1;//右区间
        while(left <= rigth)
        {
            int mid = (left+rigth)/2;//中间位置
            if(num < arr[mid])//要插入的位置还在左边
            {
                rigth = mid-1;    
            }
            else
            {
                left = mid+1;    
            }
        }
        for(int j=i-1; j>=left; j--)//移动数据  
        {
            arr[j+1] = arr[j];    
        }
        if(left != i)
        {
            arr[left] = num;
        }
    }    
}

//快速排序的基础：每一个数据都应该有一个合适的位置 使左边的数小于或等于这个数，右边的数大于或等于这个数
void quickSort(int arr[],int left,int rigth){
    int key = arr[left];
    int i=left;
    int j=rigth;
    while(j>i)
    {
        for(; j>i && arr[j]>=key; j--);//没有循环体
        if(j>i)
        {
            arr[i] = arr[j];
        }
        for(; j>i && arr[i]<=key; i++);
        if(j>i)
        {
            arr[j] = arr[i];    
        }
    }
    arr[i] = key;
    if(i-1>left)
        quickSort(arr,left,i-1);
    if(i+1<rigth)
        quickSort(arr,i+1,rigth);
}

void countSort(int arr[],int len)
{
    int max = arr[0];
    int min = arr[0];
    for(int i=1; i<len; i++)
    {
        if(min > arr[i])
        {
            min = arr[i];
        }
        if(max < arr[i])
        {
            max = arr[i];
        }
    }
    int l = max-min+1;
    int brr[l];
    for(int i=0; i<l; i++)
    {
        brr[i] = 0;
    }
    for(int i=0; i<len; i++)
    {
        brr[arr[i]-min]++;
    }
    int j=0;
    for(int i=0; i<l; i++)
    {
        while(brr[i]>0)
        {
            arr[j++] = i+min;
            brr[i]--;
        }    
    }
}