常见的几种算法排序

001.冒泡排序（Bubble Sort）

int[] arrayInt = {2,1,9,6,3,8,4,5};
for(int i=0;i<arrayInt.length;i++){
    for(int j=0;j<arrayInt.length-i-1;j++){
	    if(arrayInt[j]>arrayInt[j+1]){
		    int temp = arrayInt[j];
		    arrayInt[j]=arrayInt[j+1];
		    arrayInt[j+1]=temp;
	    }
    }
}
for(int k : arrayInt){
    System.out.print(k+" ");
}

002.选择排序

选择排序是不稳定的排序方法；找到数组中最大的元素，与数组最后一个元素互换；

int[] arrayInt = {8,2,1,5,3,6,9,7,10};
int max;
int temp;
for(int i=0;i<arrayInt.length-1;i++){
    max=0;
    for(int j=0;j<arrayInt.length-i;j++){
	    if(arrayInt[j]>arrayInt[max]){
                max=j;
	    }
	}
    temp = arrayInt[max];
    arrayInt[max]=arrayInt[arrayInt.length-i-1];
    arrayInt[arrayInt.length-i-1]=temp;
}
for(int k : arrayInt){
    System.out.print(k+" ");
}

003.插入排序

百度百科解释：插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。

int[] arrayInt = {10,3,1,5,2,6,9,7,8};
int temp;
for(int i=1;i<arrayInt.length;i++){
    //记录要插入的数据
    temp = arrayInt[i];
    while(i>=1 && arrayInt[i-1]>temp){
    	arrayInt[i] = arrayInt[i-1];
    	i--;
    }
    arrayInt[i]=temp;
}
for(int k : arrayInt){
    System.out.print(k+" ");
}

004.快速排序

找一个基准(pivot)，比它大则放右边，比它小则放左边；(平均时间复杂度为O(nlogn),最坏情况下的时间复杂度是O(n^2))

//这种来源于'Java3y'
public static void main(String[] args) {
    int[] arr = {10,3,1,5,2,16,9,7,8};
    quickSort(arr,0,8);
    System.out.println(Arrays.toString(arr));
}

public static void quickSort(int[] arr,int L,int R){
    //L指向数组第一个元素；R指向数组最后一个元素
    int i = L;
    int j = R;
    
    //基准
    int pivot = arr[(L+R)/2];
    
    //左右两端进行扫描，两端交替时结束
    while(i<=j){
    //寻找直到比基准大的数
    while(pivot > arr[i]){
    	i++;
    }
    //寻找直到比基准小的数
    while(pivot < arr[j]){
    	j--;
    }
    //这时分别找到了比基准大的数、比基准小的数，互换
    if(i<=j){
    	int temp = arr[i];
    	arr[i] = arr[j];
    	arr[j] = temp;
    	i++;
    	j--;
    }
    }
    //'左边'再做排序，直到左边剩下一个数(递归出口)
    if(L<j){
        quickSort(arr,L,j);
    }
    //'右边'再做排序，直到右边剩下一个数(递归出口)
    if(i<R){
        quickSort(arr,i,R);
    }
}

//这种来源于'程序员小灰'
public static void main(String[] args) {
    int[] arr = {10,3,1,5,2,16,9,7,8};
    quickSort(arr,0,arr.length-1);
    System.out.println(Arrays.toString(arr));
}
	
public static void quickSort(int[] arr,int startIndex,int endIndex){
	if(startIndex >= endIndex){
		return;
	}
	//得到基准元素位置
	int pivotIndex = partition(arr,startIndex,endIndex);
	//根据基准元素位置，用分治法递归数列的两部分
	quickSort(arr,startIndex,pivotIndex-1);
	quickSort(arr,pivotIndex+1,endIndex);
}

private static int partition(int[] arr,int startIndex,int endIndex){
    //取第一个位置的元素作为基准元素
    int pivot = arr[startIndex];
    int left = startIndex;
    int right = endIndex;
    
    //坑的位置，初始等于pivot的位置
    int index = startIndex;
    
    //大循环在左右指针重合或交错时结束
    while(right>=left){
    	//right指针从左向右进行比较
    	while(right>=left){
    		if(arr[right]<pivot){
    			arr[left] = arr[right];
    			index = right;
    			left++;
    			break;
    		}
    		right--;
    	}
    	//left指针从左向右进行比较
    	while(right>=left){
    		if(arr[left]>pivot){
    			arr[right] = arr[left];
    			index = left;
    			right--;
    			break;
    		}
    		left++;
    	}			
    }
    arr[index]=pivot;		
    return index;
}