冒泡排序和快速排序(Java)

冒泡排序

原理：

在无序区间，通过相邻数之间的比较，将无序区间最大的数冒泡到无序区间的末位，持续这个过程，直到数组整体有序。

代码实现：

public void bubbleSort(int[] array){
	
	for(int i = 0;i < array.length-1;i++){
		boolean isSorted = true;
		for(int j = 0;j < array.length-1-i;j++){
			if(array[j] > array[j+1]){
				int temp = array[j];
				array[j] = array[j+1];
				array[j+1] = array[j];
				isSorted = false;
			}
		}
		if(isSorted){
			break;
		}
	}
}

时间复杂度：
最好情况(数据有序)：O（n）
最坏情况(数据逆序)：O（n^2）
平均情况：O（n^2）

稳定

快速排序

原理：

1. 从待排序区间选择一个数，作为基准值(首位、末位、左右中三数取中，三种方法均可)；
2. Partition: 遍历整个待排序区间，将比基准值小的（包含相等的）放到基准值的左边，将比基准值大的放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式递归处理，直到小区间的长度 == 1，即start = end，代表已经有序；或者小区间的长度 == 0，代表没有数据。

public void quickSort(int[] array){
        sortInterval(array,0,array.length-1);
}

private void sortInterval(int[] array, int start, int end) {  
//start、end: 排序区间的首位和末位的下标
        if(start == end || start > end){
            return;
        }
        int keyIndex = partition(array,start,end); //对待排序区间进行排序，返回
        sortInterval(array,0,keyIndex-1);
        sortInterval(array,keyIndex+1,end);
}

private int partition(int[] array, int start, int end) {
        int temp = array[start];

        while(start < end){
            while(start < end){
                if(array[end] > temp){
                    end--;
                }else{
                    array[start++] = array[end];
                    break;
                }
            }
            while(start < end){
                if(array[start] < temp){
                    start++;
                }else{
                    array[end--] = array[start];
                    break;
                }
            }
        }

        if(start == end){
            array[start] = temp;
        }

        return start;
}

时间复杂度：
最好情况：O（nlogn）
最坏情况：O（n^2）
平均时间复杂度：O（nlogn）

不稳定