排序

常见的排序算法总结。

冒泡排序：

void bubbleSort (vector<int>& nums) {
    int i,j;
    bool flag=true;
    for(i=0;i<nums.size()-1;i++){
        for(j=0;j<nums.size()-i-1;j++){
            if(nums[j]>nums[j+1]){
                int temp=nums[j+1];
                nums[j+1]=nums[j];
                nums[j]=temp;
                flag=false;
            }
        }
        if(flag)
            break;
    }
}

简单选择排序：

void selectSort(vector<int>&array){
    for(int i=0;i<array.size()-1;i++){
        int maxVal=array[0];
        int maxIndex=0;
        for(int j=0;j<array.size()-1-i;j++){
            if(array[j]>maxVal){
                maxVal=array[j];
                maxIndex=j;
            }
        }
    swap(array[array.size()-1-i],array[maxIndex]);
    }
}

插入排序：

void insertSort(vector<int>&array){
    for(int i=1;i<=array.size()-1;i++){
        int temp=array[i];
        int j=i-1;
        for(;j>=0 && array[j]>temp;j--)
                array[j+1]=array[j];
        array[j+1]=temp;
    }
}

快速排序：

void quickSort(vector<int>& nums) {
    if(nums.size()==0)
        return ;
    Sort(nums,0,nums.size()-1);
}
void Sort(vector<int> &nums,int numBegin,int numEnd){
    if(numBegin>=numEnd)
        return;
    int temp=nums[numBegin];
    int i=numBegin,j=numEnd;
    While(i<j){
        while(i<j&&nums[j]>=temp)
            j--;
        if(i<j)
            nums[i++]=nums[j];
        while(i<j&&nums[i]<=temp)
            i++;
        if(i<j)
            nums[j--]=nums[i];
    }
    nums[i]=temp;
    Sort(nums,numBegin,i-1);
    Sort(nums,i+1,numEnd);
}

堆排序：

void heapAjust(vector<int>&array,int i,int length){
    for(int j=2*i+1;j<length;j=j*2+1){
        if(j+1<length && array[j]<array[j+1])
            j++;//
        if(array[j]>array[(j-1)/2]){
            swap(array[j],array[(j-1)/2]);
        }
    }
}
void heapSort(vector<int>&array){
    for(int i=array.size()/2-1;i>=0;i--){
        heapAjust(array,i,array.size());
    }
    for(int i=array.size()-1;i>=0;i--){
        swap(array[0],array[i]);
        heapAjust(array,0,i);
    }
}

归并排序：

void merge(vector<int>&array,int left,int mid,int right){
    vector<int>temp(right-left+1);
    int low=left,high=right,middle=mid+1;
    int cur=0;
    while(low<=mid&&middle<=high){
        if(array[low]<=array[middle])
            temp[cur++]=array[low++];
        else 
            temp[cur++]=array[middle++];
    }
    while(low<=mid)
        temp[cur++]=array[low++];
    while(middle<=high)
        temp[cur++]=array[middle++];
    cur=0;
    while(cur<temp.size())
        array[left++]=temp[cur++];
}
void mergeSort(vector<int>&array,int left,int right){
    if(left>=right)
        return ;
    int mid=left+(right-left)/2;
    mergeSort(array,left,mid);
    mergeSort(array,mid+1,right);
    merge(array,left,mid,right);
}

希尔排序：

void shell(vector<int>&array,const int step){
    for(int i=0;i<step;i++){
        for(int j=i+step;j<array.size();j+=step){
            int temp=array[j];
            int k=j-step;
            for(;k>=i&&array[k]>temp;k-=step)
                array[k+step]=array[k];
            array[k+step]=temp;
        }
    }
}
void shellSort(vector<int>&array,const vector<int>&step){
    for(int i=0;i<step.size();i++){
        shell(array,step[i]);
    }
}