常用排序算法中复杂度为o(n2),o(n log(n)),冒泡和选择为o(n2)，堆排序和快速排序为o(n log(n))。

1.冒泡排序

主要思路：每一趟从第一个数开始，两两比较，如果nums[i] > nums[i + 1]，则将两数交换，共比较nums.length - 1趟数。改进版是某一趟没有发生交换，则停止。

代码易错点。

    boolean swaped = true;
    for(int i = 0; i < nums.length - 1; i++){
    //如果上一次没有交换，则停止
    //如果满足条件，则。。。可以写为为如果不满足条件则直接退出
    if(!swaped) break;
    //每一趟都默认不会发生交换
    swaped = false;
    //每一趟只比较到nums.length-i处，后面的都是排好序的大数
    for(int j = 0; j < nums.length - 1 - i; j++){
        if(nums[j] > nums[j+1]){
            swap(nums, j, j+1);
            swaped = true;
        }
    }
    }

2.选择排序

主要思路：每i趟找到最小的元素，与数组元素i交换。

        int minIndex;
        for(int i = 0; i < arr.length - 1; i++){
            minIndex = i;
            for(int j = i + 1; j < arr.length; j++){
                if(arr[j] < arr[minIndex])minIndex = j;
            }
            swap(arr, i, minIndex);
        }

3.堆排序

主要思路：首先构建堆，然将对顶元素换到数组末尾，再堆交换后的堆进行调整。

代码易错点：

    public static void buildMaxHeap(int[] arr){
        //从最后一个非叶子节点开始调整：i = arr.length / 2 - 1
        //从根节点也要调整，即i >= 0
        for(int i = arr.length / 2 - 1; i >= 0; i--){
            maxHeapfy(arr, i, arr.length);
        }
    }

    //调整函数
    public static void maxHeapfy(int[] arr, int i, int heapSize){
        int largest = i;
        //左孩子节点为2 * i + 1，别忘记加1
        int l = 2 * i + 1;
        int r = l + 1;
        //左右孩子节点都要小于待排序的元素最大下标，heapsize是待排序的元素个数
        if(l < heapSize && arr[l] > arr[largest])largest = l;
        if(r < heapSize && arr[r] > arr[largest])largest = r;
        //如果largest不是根节点，才交换和调整
        if(largest != i){
            swap(arr, i, largest);
            maxHeapfy(arr, largest, heapSize);   
        }
    }

4.快速排序：