十种排序算法-C++实现

冒泡排序，插入排序，选择排序，快排，归并排序，希尔排序，堆排序，桶排序，计数排序，基数排序

template<typename T>
void swap2(T &a,T &b){
    T temp=a;
    a=b;
    b=temp;
}

//冒泡排序
template<typename T>
void bubble(vector<T> &array){
    int n=array.size();
    for(int i=0;i<n-1;i++){
        for(int j=0;j<n-i-1;j++){
            if(array[j]>array[j+1]){
                swap2(array[j],array[j+1]);
            }
        }
    }
}

//插入排序
template<typename T>
void insertSort(vector<T> &array){
    int n=array.size();
    for(int i=1;i<n;i++){
        for(int j=i;j>0;j--){
            if(array[j]>array[j-1])
                swap2(array[j],array[j-1]);
        }
    }
}

//选择排序
template<typename T>
void selectSort(vector<T> &array){
    int n=array.size();
    for(int i=0;i<n-1;i++){
        int index=i;
        for(int j=i+1;j<n;j++){
            if(array[j]<array[index]){
                index=j;
            }
        }
        swap2(array[i],array[index]);
    }
}

//快排
template<typename T>
int partition(vector<T> &array,int low,int high){
    T pivot=array[low];
    while(low<high){
        while(low<high&&array[high]>=pivot)
            --high;
        array[low]=array[high];
        while(low<high&&array[low]<=pivot)
            ++low;
        array[high]=array[low];
    }
    array[low]=pivot;
    return low;
}

template<typename T>
void quickSort(vector<T> &array,int low,int high){
    if(low<high){
        int pivot= partition(array,low,high);
        quickSort(array,low,pivot-1);
        quickSort(array,pivot+1,high);
    }
}
//希尔排序
template<typename T>
void shellSort(vector<T> &array){
    int n=array.size();
    int step=n>>1;
    while(step>=1){
        for(int i=step;i<n;i++){
            for(int j=i;j>=step;j-=step){
                if(array[j]<array[j-step]){
                    swap(array[j],array[j-step]);
                }else{
                    break;
                    //如果大于，不用继续往前比较了，因为前面的都排好序了
                }
            }
        }
        step>>=1;
    }
}


//归并排序
template<typename T>
void merge(vector<T> &array,int left,int mid,int right){
    vector<T> LeftSubArray(array.begin()+left,array.begin()+mid+1);
    vector<T> RightSubArray(array.begin()+mid+1,array.begin()+right+1);
    int idxLeft = 0, idxRight = 0;
    LeftSubArray.insert(LeftSubArray.end(), numeric_limits<int>::max());
    RightSubArray.insert(RightSubArray.end(), numeric_limits<int>::max());
    for (int i = left; i <= right; i++) {
        if (LeftSubArray[idxLeft] < RightSubArray[idxRight]) {
            array[i] = LeftSubArray[idxLeft];
            idxLeft++;
        } else {
            array[i] = RightSubArray[idxRight];
            idxRight++;
        }
    }
}

template<typename T>
void mergeSort(vector<T> &array,int left,int right){
    if(left>=right)return;
    int mid=(left+right)/2;
    mergeSort(array,left,mid);
    mergeSort(array,mid+1,right);
    merge(array,left,mid,right);
}

//堆排序
/*
 * 堆排序的基本思想是：将待排序序列构造成一个大顶堆，
 * 此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。
 * 然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了
 * */

template<typename T>
void heapSort(vector<T> &array){
    //构建大顶堆
    for(int i=array.size()/2-1;i>=0;i--){
        adjustHeap(array,i,array.size());
    }

    //调整堆结构+交换堆顶元素与末尾元素
    for(int j=array.size()-1;j>0;j--){
        swap(array[0],array[j]);//将堆顶元素与末尾元素交换
        //重新对堆进行调整
        adjustHeap(array,0,j);
    }
}

//大顶堆，得到由小到大有序序列
template<typename T>
void adjustHeap(vector<T> &array,int i,int length){
    T temp=array[i];
    for(int k=i*2+1;k<length;k=k*2+1){
        if(k+1<length&&array[k]<array[k+1]){//如果左子节点小于右子节点，k指向右子节点
            k++;
        }
        if(array[k]>temp){//如果子节点大于父节点，将子节点赋值给父节点，不用交换
            array[i]=array[k];
            i=k;
        }else{
            break;
        }
    }
    array[i]=temp;//将temp值放到最终的位置
}


//小顶堆，得到由大到小有序序列
template<typename T>
void adjustHeap1(vector<T> &array,int i,int length){
    T temp=array[i];
    for(int k=2*i+1;k<length;k=2*k+1){
        if(k+1<length&&array[k]>array[k+1]){
            k++;//如果左子节点大于右子节点，k指向右子节点
        }
        if(array[k]<temp){//如果子节点小于父节点，将子节点赋值给父节点，不用交换
            array[i]=array[k];
            i=k;
        }else{
            break;
        }
    }
    array[i]=temp;
}

//桶排序
template<typename T>
void bucketSort(vector<T> &array,int bucketSize){
    int n=array.size();
    int max=array[0];
    int min=array[0];
    for(int i=0;i<n;i++){
        if(array[i]>max){
            max=array[i];
        }else if(array[i]<min){
            min=array[i];
        }
    }

    int bucketNum=(max-min)/bucketSize+1;
    vector<vector<T>> buckets(bucketNum);
    for(int i=0;i<n;i++){
        int x=(array[i]-min)/bucketSize;
        buckets[x].push_back(array[i]);
    }

    int curIndex=0;
    for(int i=0;i<bucketNum;i++){
        shellSort(buckets[i]);
        for(int j=0;j<buckets[i].size();j++){
            array[curIndex++]=buckets[i][j];
        }
    }
}


//计数排序
template<typename T>
void countSort(vector<T> &array){
    int n=array.size();
    T max=array[0];
    T min=array[0];

    for(int i=0;i<array.size();i++){
        if(array[i]>max)
            max=array[i];
        else if(array[i]<min)
            min=array[i];
    }

    int countNum=max-min+1;//计数器数量
    vector<T> buckets(countNum);
    for(int i=0;i<n;i++){
        buckets[array[i]-min]++;//落在某个桶里就加1
    }

    //从小到大排序
   /* for(int i=1;i<countNum;i++){
        buckets[i]=buckets[i]+buckets[i-1];
    }*/
    //从大到小排序
    for(int i=countNum-1;i>0;i--){
        buckets[i-1]=buckets[i]+buckets[i-1];
    }

   vector<T> temp(array.begin(),array.end());
    for(int i=0;i<n;i++){
        //temp[i]-min是这个值和最小值的差
        //--buckets[array[i]-min]是这个值应该在array中的位置
        array[--buckets[temp[i]-min]]=temp[i];
    }
}

//基数排序
template<typename T>
void radixSort(vector<T> &array){
    int digitCount=10;
    int maxCount= getBitCount(getMaxNum(array));
    int radix=1;

}

int getBitCount(int num){
    int count=1;
    int temp=num/10;
    while(temp){
        count++;
        temp/10;
    }
    return count;
}

template<typename T>
T getMaxNum(const vector<T> &array){
    T max=array[0];
    for(int i=1;i<array.size();i++){
        if(array[i]>max){
            max=array[i];
        }
    }
    return max;
}