排序算法

冒泡排序

原理：依次比较相邻元素，每次比较结束，最后的元素即最大的，就可以不用参与比较

void bubble_sort(vector<int>&a){
    int len=a.size();
    for(int i=0;i<len-1;i++){
        for(int j=0;j<len-i-1;j++){
            if(a[j+1]<a[j]){
                int tmp=a[j+1];
                a[j+1]=a[j];
                a[j]=tmp;
            }
        }
    }  
}

选择排序

原理：在未排序的序列中找到最小元素，放在序列的起始位置

void select_sort(vector<int>&a){
    int len=a.size();
    for(int i=0;i<len;i++){
        int minIndex=i;
        for(int j=i+1;j<len;j++){
            if(a[j]<a[minIndex])
            minIndex=j;
        }
        if(i!=minIndex){
            int tmp=a[i];
            a[i]=a[minIndex];
            a[minIndex]=tmp;
        }
    }
}

插入排序

原理：把第一个元素看作一个有序序列，剩下的元素看作未排序的序列，遍历未排序序列，将遍历的每个元素插入到有序序列的适当位置

void insert_sort(vector<int>&a){
    int len=a.size();
    for(int i=1;i<len;i++){
        for(int j=i;j>0;j--){
            if(a[j]<a[j-1]){
                int tmp=a[j-1];
                a[j-1]=a[j];
                a[j]=tmp;
            }
        }
    }
}

希尔排序

原理：将待排序的序列分割成若干子序列分别进入插入排序

void shell_sort(vector<int>&a){
    int len=a.size();
    int h=1;
    while(h<len/3)
    h=3*h+1;
    while(h>=1){
        for(int i=h;i<len;i++){
            int e=a[i];
            int j;
            for(j=i;j>=h&&e<a[j-h];j-=h)
            a[j]=a[j-h];
            a[j]=e;
        }
        h/=3;
    }
}

归并排序

原理：分治思想，分割子序列，使得子序列有序，在合并

void Mergesort(vector<int>& nums, int l, int r, vector<int>& tmp) {
		if (l < r) {
			int mid = (l + r)/ 2;
			Mergesort(nums, l, mid, tmp, res);
			Mergesort(nums, mid + 1, r, tmp, res);
			int lpos = l, rpos = mid + 1, tpos = l;
			while (lpos <= mid && rpos <= r) {
				if (nums[rpos] < nums[lpos]) {
					tmp[tpos++] = nums[rpos++];
				}
				else {
					tmp[tpos++] = nums[lpos++];
				}
			}
			while (lpos <= mid) {
				tmp[tpos++] = nums[lpos++];
			}
			while (rpos <= r) {
				tmp[tpos++] = nums[rpos++];
			}
			while (l <= r) {
				nums[l] = tmp[l];
				l++;
			}
		}
	}

快速排序

原理：从数列中挑一个数作为基准，序列中比基准小的放左边，大的放右边，然后递归的进行此操作

int parititional(vector<int>&a,int low,int high){
        int pivot=a[low];
        while(low<high){
            while(low<high&&a[high]>=pivot)
            high--;
            a[low]=a[high];
            while(low<high&&a[low]<=pivot)
            low++;
            a[high]=a[low];
        }
        a[low]=pivot;
        return low;
    }
    void quick_sort(vector<int>&a,int low,int high){
        if(low<high){
            int pivot=parititional(a,low,high);
            quick_sort(a,low,pivot-1);
            quick_sort(a,pivot+1,high);
        }
    }