常用的几种排序（冒泡，插入，选择，快速，）

一、快速排序排大小

基本概念

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

代码实现

package 快速排序;

import java.util.Arrays;

public class QuickSort {
	public static void main(String[] args) {
		int nums[]= {10,3,5,4,1,2,8,7,9};
		//3 5 4  7
		/*
		 * 9 3 5 4 1 2 8 7  10 一轮比完
		 * ------------
		 * 7 3 5 4 1 2 8  9 10  二轮比完
		 * ----------
		 * 2 3 5 4 1    7 8 9 10 三轮比完
		 * -----------
		 * 1 3 5 4 2 
		 * （1） 2 （5 4 3）   
		 *  1 2 3 4 5
		 */
		//从小到大排序
		/*
		 * 假设nums[0]是中间值，要让中间值的左边都比他小，右边比他大。
		 * 先从右往左找比中间值小的，再从左往右找比中间值大的。
		 */
		System.out.println(Arrays.toString(sort(nums,0,nums.length-1)));
	}

	private static int[] sort(int[] nums, int start, int end) {
		// TODO Auto-generated method stub
		int _start=start;
		int _end=end;
		while(start<end) {
			for(;end>start;end--) {
				if(nums[end]<nums[start]) {
					int temp=nums[end];
					nums[end]=nums[start];
					nums[start]=temp;
					break;
				}
			}
			for(;start<end;start++) {
				if(nums[end]<nums[start]) {
					int temp=nums[start];
					nums[start]=nums[end];
					nums[end]=temp;
					break;
				}
			}
		}
		//第一轮比完start和end在10的位置。
		//接着再比10的两边，和第一轮一样。
		if(_start<start-1) {
			sort(nums,_start,start-1);
		}
		if(end+1<_end) {
			sort(nums,end+1,_end);
		}
		return nums;
	}
}

测试结果

二、选择排序

选择排序为什么叫选择排序呢?他的原理就是选择当前的元素依次和后面的元素进行比较，在第一次比较之后就会将我们想要的结果放在首位，然后接着从第二个元素开始依次和后面的元素进行比较。假如说有8个元素，那么试想一下我们到底应该比几轮？答案是7轮,为什么呢？因为我们第一轮比较完已经将我们要的一个数放在了数组的最左边，再一个就是第8轮也就是最后一个元素后面已经没有值了，那么就不用比了。

代码实现

class Solution {
    public int[] sortArrayByParity(int[] A) {
        if(A==null||A.length==1){
            return A;
        }
        //选择排序
        int temp=0;
        /*
        注意，外层循环控制轮数也参与计算
        */
        for(int i=0;i<A.length-1;i++){//最后一轮由于前面已经排好而且最后一轮后面已经没值了，
            //所以只需要比A.length-1轮
            for(int j=i+1;j<A.length;j++){
                if(A[i]%2==1&&A[j]%2==0){//前奇数后偶数，就交换
                    temp=A[i];
                    A[i]=A[j];
                    A[j]=temp;
                }
            }
        }
        return A;
    }
}

三、冒泡排序

冒泡排序，就是两两相比，类似于鱼吐泡泡那种，和选择排序不同的是，冒牌排序第一轮排完就将我们要的其中一个值放到了最后，也就是数组的尾部。和选择相同的是冒泡排序也是少比一轮。而且冒泡排序每轮比完都会得出一个结果并将这个结果放在最右边，所以下一轮比的次数总是会比上一轮少一次。

代码实现

class Solution {
    public int[] sortArrayByParity(int[] A) {
        if(A==null||A.length==1){
            return A;
        }
        //冒泡排序
        //每次都从0开始比，
        int temp=0;
        for(int i=0;i<A.length-1;i++){//最后一轮没有比较的了，所以少比一轮。
            //i只控制轮数，不参与运算
            for(int j=0;j<A.length-1-i;j++){//j参与运算
                if(A[j]%2==1&&A[j+1]%2==0){//前奇数后偶数
                    temp=A[j+1];
                    A[j+1]=A[j];
                    A[j]=temp;
                }
            }      
        }
        return A;
    }
}

四、插入排序

代码实现

class Solution {
    public int[] sortArrayByParity(int[] A) {
        if(A==null||A.length==1){
            return A;
        }
        //插入排序
        for(int i=1;i<A.length;i++){
            int e=A[i];
            int j;
            for(j=i;j-1>=0&&A[j-1]%2==1&&e%2==0;j--){
                A[j]=A[j-1];
            }
            A[j]=e;
        }
        return A;
    }
}

插入排序排数字的大小代码实现（C语言）

void main(){
    int a[]={3,1,2,6,5,9,7,4,8};
    int len=sizeof(a)/sizeof(int);

    for(int i=1;i<len;i++){
        int e=a[i];
        int j;
        for(j=i;j-1>=0&&a[j-1]>e;j--){
            // if(j-1<0){//j左边的牌 没有 j-1<0
            //     break;
            // }else{
            //     if(a[j-1]>a[j]){//左边大于当前
            // int temp=a[j];
            // a[j]=a[j-1];
            // a[j-1]=temp;
                a[j]=a[j-1];
            //     }else{//左边 小于等于当前
            //         break;
            //     }
            // }
        }
        a[j]=e;
    }
    printf("[");
    for(int i=0;i<len;i++){
        if(i==len-1){
            printf("%d]\n",a[i]);
        }else{
            printf("%d,",a[i]);
        }
    }
}