C++ 八大排序

C++ 八大排序

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

#define N 10
//冒泡排序
void bubbleSort(int *arr,int len) {
    for(int i=0;i<len-1;i++) {
        for(int j=0;j<len-1-i;j++) {
            if(arr[j]>arr[j+1]) {
                int tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
            }
        }
    }
}
//插入排序
void insertSort(int *arr,int len) {
    for(int i=1;i<len;i++) {
        int k=i-1;
        int temp=arr[i];
        while(arr[k]>temp && k>=0) {
            arr[k+1]=arr[k];
            k--;
        }
        arr[k+1]=temp;
    }
}
//快速排序
void quickSort(int *arr,int begin,int end) {
    if(begin<end) {
        int i=begin,j=end;
        int tmp=arr[begin];
        while(i<j) {
            while(i<j && arr[j]>tmp) --j;
            arr[i]=arr[j];
            while(i<j && arr[i]<tmp) ++i;
            arr[j]=arr[i];
        }
        arr[i]=tmp;
        quickSort(arr,begin,i-1);
        quickSort(arr,i+1,end);
    }
}
//选择排序
void selectSort(int *arr,int len) {
    for(int i=0;i<len-1;i++) {
        int min=i;
        for(int j=i+1;j<len;j++) {
            if(arr[j]<arr[min]) min=j;
        }
        swap(arr[i],arr[min]);
    }
}
//希尔排序
void shellSort(int *arr,int len) {
    for(int step=len>>1;step>0;step>>=1) {
        for(int i=step;i<len;i++) {
            int tmp=arr[i];
            int k=i-step;
            while(k>=0 && arr[k]>tmp) {
                arr[k+step]=arr[k];
                k-=step;
            }
            arr[k+step]=tmp;
        }
    }
}

void merge(int *arr,int begin,int mid,int end) {
    int tmp[N];
    int i=begin,j=mid+1,k=0;
    while(i<=mid && j<=end) {
        if(arr[i]<arr[j]) {
            tmp[k++]=arr[i++];
        }
        else {
            tmp[k++]=arr[j++];
        }
    }
    while(i<=mid) tmp[k++]=arr[i++];
    while(j<=end) tmp[k++]=arr[j++];
    k=0;
    for(int i=begin;i<=end;i++,k++) {
        arr[i]=tmp[k];
    }
}
//归并排序
void mergeSort(int *arr,int begin,int end) {
    if(begin<end) {
        int mid=(begin+end)>>1;
        mergeSort(arr,begin,mid);
        mergeSort(arr,mid+1,end);
        merge(arr,begin,mid,end);
    }
}

void adjustHeap(int *arr,int index,int len) {
    int left=index*2+1;
    int right=index*2+2;
    int maxIdx=index;
    if(left<len && arr[left]>arr[maxIdx]) maxIdx=left;
    if(right<len && arr[right]>arr[maxIdx]) maxIdx=right;
    if(maxIdx!=index) {
        swap(arr[index],arr[maxIdx]);
        adjustHeap(arr,maxIdx,len);
    }
}
//堆排序
void heapSort(int *arr,int len) {
    for(int i=len/2-1;i>=0;i--) {
        adjustHeap(arr,i,len);
    }
    for(int j=len-1;j>0;j--) {
        swap(arr[0],arr[j]);
        adjustHeap(arr,0,j);
    }
}

int bitCount(int *arr,int len) {
    int bit=1;
    int p=10;
    for(int i=0;i<len;i++) {
        while(arr[i]>p) {
            p*=10;
            ++bit;
        }
    }
    return bit;
}
//基数排序
void radixSort(int *arr,int len) {
    int bit=bitCount(arr,len);
    vector<queue<int>> container(10);
    for(int b=0;b<bit;b++) {
        for(int i=0;i<len;i++) {
            int tmp=arr[i];
            for(int j=0;j<b;j++) tmp/=10;
            container[tmp%10].push(arr[i]);
        }
        for(int k=0,i=0;k<10;k++) {
            while(!container[k].empty()) {
                arr[i++]=container[k].front();
                container[k].pop();
            }
        }
    }
}

void myPrint(int *num) {
    cout << "[";
    for(int i=0;i<N-1;i++) {
        cout << num[i] << ",";
    }
    cout << num[N-1] << "]" << endl;
}

int main() {
    int num[N]={7,8,11,6,5,4,3,2,1,1};

    //bubbleSort(num,N);
    //insertSort(num,N);
    //quickSort(num,0,N-1);
    //selectSort(num,N);
    //shellSort(num,N);
    //mergeSort(num,0,N-1);
    //heapSort(num,N);
    radixSort(num,N);

    myPrint(num);
    return 0;
}

后续完成时间复杂度、空间复杂度以及稳定性的内容补充、、、