java常用排序算法

冒泡排序算法：

public static void bubbSort(int[] a){
		 for (int j = 0; j < a.length; j++){
	          for (int i = 0; i < a.length - j - 1; i++) {
			       if (a[i] > a[i + 1]){
			           int temp = a[i + 1];
			           a[i + 1] = a[i];
			           a[i] = temp;
			       }
	          }
		 }
	}

算法思想：由数组头部开始，每次比较两个元素，顺序不满足就进行交换，当前数组最大值（最小值）会被放在最后。一趟排序完成，然后同样的方法进行后面的比较。

插入排序算法：

public static void insSort(int[] a) {
        // 插入排序
        for (int i = 0; i < a.length; i++) {
            int k = i;
            // 找出最小值的坐标
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < a[k]) {
                    k = j;
                }
            }
            //最小的放到开始位置
            if (k > i) {
                a[i]=(a[k]^=(a[i]^=a[k]))^a[i];//使用异或交换，不需要中间变量，进行两个变量的数值交换
            }
        }
        //打印排好序的数组
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

算法思想：选取第一个数为基准数，让标记指向它的坐标值，然后与后面剩余的数进行比较，如果遇见比基准数小的，与其值进行交换，把标记指向新的基准数的坐标，以此类推，走完一次比较之后，最小的数找到了，然后再使用同样的方法找第二小的数，最终完成排序。

快速排序算法：

  

  public static int[] quickSort(int[] a,int low,int high){
        int start = low;
        int end = high;
        int key = a[low];               
        /***
         * 进行一次比较，关键值左右两部分，一部分比它小，一部分比它大
         */
        while( end > start ){
            //从后往前比较
            while( end > start && a[end] >= key){//查找比关键值小的，如果沒有就比较下一个
                end--;
            }  
            if( a[end] <= key){  //直到有比关键值小的交换位置
                a[start]=(a[end]^=(a[start]^=a[end]))^a[start];
            }
            //从前往后比较
            while( end> start && a[start] <= key){//查找比关键值大的，如果沒有就比较下一个
               start++;
            }
            if(a[start]>=key){ //直到有比关键值大的交换位置
                a[start]=(a[end]^=(a[start]^=a[end]))^a[start];             
            }
        }
        /**
         * 对左右两部分分别进行递归
         */
        if(start>low){        
            quickSort(a,low,start-1);
        }          
        if(end<high){            
            quickSort(a,end+1,high);
        }
       return a;
    }

算法思想：找一个基准值，一般以第一个数为基准值，从后往前比较，用基准值和最后一个值比较，找比基准值小的，如果找到交换位置，否则继续比较下一个。直到找到这个值，又从前往后开始比较，如果找到比基准值大的，交换位置，否则继续比较下一个，直到找到比基准值大的值才交换。最后到从前往后的比较索引大于等于从后往前比较的索引，结束第一次循环。基准值两边，一部分全小于它，一部分全大于它，把这两部分用上面的方法进行递归，直到它是个有序数列结束。