排序——选择排序

• 每轮排序选择未排序序列的最小值放到已排序序列的末尾
• 每轮排序后就能确定一个元素的位置

void simpleSelectionSort(int* arr,int len) {
    for (int i = 0; i < len-1; i++) {
        int mi = i;			//未排序序列最小值的下标
        for (int j = i+1; j < len; j++) {
            if (arr[j] < arr[mi]) {
                mi = j;
            }
        }
        int temp = arr[i];	//将最小值添加到已有序序列末尾
        arr[i] = arr[mi];
        arr[mi] = temp;
    }
}

• 不稳定算法。例如：序列5(1)，5(2)，3，2。第一轮排序后为2，5(2)，3，5(1)
• 空间复杂度为O(1)
• 最好、平均、最坏时间复杂度均为O(n²)

• 简单选择排序中每次选择一个最大值需要遍历整个序列，查找复杂度为O(n)。堆排序则是利用堆的特性来优化查找最大值的过程
• 最大堆是一个完全二叉树，且每个结点的值不小于左右孩子的值
• 最大堆中堆顶元素即为最大值，每次从最大堆中取出最大值放到已有序序列中，然后重新调整堆

//向下调整，先找出最大的孩子，比较当前值与孩子的值
void adjustDown(int* arr,int len,int now) {	
    while (2*now+1 < len) {
        int bigger = 2*now + 1;
        if (2*now+2 < len && arr[2*now+1] < arr[2*now+2]) {
            bigger = 2*now + 2;
        }
        if (arr[now] < arr[bigger]) {
            int temp = arr[now];
            arr[now] = arr[bigger];
            arr[bigger] = temp;
            now = bigger;
            continue;
        }
        break;
    }
}

void heapSort(int* arr,int len) {
	//构建一个最大堆，从最后一个非叶子结点开始调整
    for (int i = len/2 - 1; i >= 0; i--) {
        adjustDown(arr,len,i);
    }

	//依次从最大堆中取出最大值，放到已有序序列中
    for (int i = len-1; i > 0; i--) {
        int temp = arr[i];
        arr[i] = arr[0];
        arr[0] = temp;
        adjustDown(arr,i,0);	//重新调整
    }
}

• 不稳定算法
• 堆排序每次只对一个元素操作，是就地排序，空间复杂度为O(1)
• 初始构建最大堆时，对于每个非终端结点来说，最多进行两次比较和互换操作，因此时间复杂度是O(n)，每次调整的时间复杂度是O(logn)
• 最好、平均、最坏时间复杂度均为O(nlogn)