排序——交换排序

• 每轮排序过程中，如果相邻的元素逆序就交换它们的位置使其有序，因此每轮排序都会选出一个当前的最大值
• 每轮排序都有一个元素确定位置

void bubbleSort(int* arr,int len) {
    bool isSorted;		//如果已经有序，提前退出循环
    for (int i = len-1; i > 0; i--) {	//len-1次循环
        isSorted = true;
        for (int j = 0; j < i; j++) {
            if (arr[j] > arr[j+1]) {
                isSorted = false;
                int temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        if (isSorted) {
            break;
        }
    }
}

• 空间复杂度为O(1)
• 当序列已经有序时，有最好时间复杂度O(n)
• 当序列逆序时，有最坏时间复杂度O(n²)
• 平均时间复杂度为O(n²)

• 选择一个元素作为基准。一般是第一个元素，如果选择其它元素，需要将该元素与第一个元素交互位置，即基准必须位于第一个元素。选择的基准最好能将序列分成相等的两部分。
• 每轮排序使得基准左边的元素均小于基准，基准右边的元素均大于基准（等于基准的元素在左边或右边均可）
• 按照同样的思想分治左部分与右部分
• 每轮排序都有一个元素确定位置（即基准）

//左闭右开[start,end)
void quickSort(int* arr,int start,int end) {
	//只有一个元素直接退出
    if (end - start <= 1) {
        return;
    }
    int pivot = arr[start];			//选择基准
    int left = start,right = end-1;
    while(left < right) {
    	//从后向前找小于基准的值
        while (left < right && arr[right] >= pivot ) {
            right--;
        }
        arr[left] = arr[right];
        
        //从前向后找大于基准的值
        while (left < right && arr[left] <= pivot) {
            left++;
        }
        arr[right] = arr[left];
    }
    //此时left==right,即基准的最终位置
    arr[left] = pivot;
    
    quickSort(arr,start,left);	//分治左部分
    quickSort(arr,left+1,end);	//分治右部分
}

• 不稳定算法
• 过程中使用了递归，空间复杂度为递归栈的深度。最好与平均均为O(logn)，最坏可达到O(n)
• 当选取的基准恰好将序列分成长度相等的两部分时，有最好时间复杂度为O(nlogn)
• 当选取的基准恰好将序列分成长度相差很大的两部分时，有最坏时间复杂度为O(n²)
• 平均时间复杂度为O(nlogn)