（一）常用排序总结

数组交换

public static void swap(int[] arr, int index1, int index2) {
    arr[index1] = arr[index1] ^ arr[index2];
    arr[index2] = arr[index1] ^ arr[index2];
    arr[index1] = arr[index1] ^ arr[index2];
}
public static void swap(int[] arr, int index1, int index2) {
        int temp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = temp;
}

1. 冒泡排序

public static void bubbleSort(int[] arr) {
    for (int i = arr.length - 1; i > 0; i--) {
        for (int j = 0; j < i; j++) {
            if (arr[i] > arr[i + 1]) {
                swap(arr, i, i + 1);
            }
        }
    }
}

2. 选择排序

public static void selectionSort(int[] arr) {
    if (arr == null || arr.length < 2){
        return;
    }
    for (int i = 0; i < arr.length - 1; i++) {
        int min = i;
        for (int j = i + 1; j < arr.length; j++) {
            min = arr[j] < arr[min] ? j : min;
        }
        swap(arr, min, i);
    }
}

3. 插入排序

public static void insertionSort(int[] arr) {
    for (int i = 1; i < arr.length - 1; i++) {
        for (int j = i - 1; j > 0 && arr[j] > arr[j + 1]; j--) {
            swap(arr, j, j + 1);
        }
    }
}

4. 归并排序

   public static void mergeSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        mergeSort(arr, 0, arr.length - 1);
    }

    public static void mergeSort(int[] arr, int l, int r) {
        if (l == r) {
            return;
        }
        int mid = l + ((r - l) >> 1);
        mergeSort(arr, l, mid);
        mergeSort(arr, mid + 1, r);
        merge(arr, l, mid, r);
    }

    public static void merge(int[] arr, int l, int m, int r) {
        int[] help = new int[r - l + 1];
        int i = 0;
        int p1 = l;
        int p2 = m + 1;
        while (p1 <= m && p2 <= r) {
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= m) {
            help[i++] = arr[p1++];
        }
        while (p2 <= r) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
    }

5. 快速排序
荷兰国旗问题（给定基准）

public static int[] partition(int[] arr, int l, int r, int p) {
    int less = l - 1;
    int more = r + 1;
    while (l < more) {
        if (arr[l] < p) {
            swap(arr, ++less, l++);
        } else if (arr[l] > p) {
            swap(arr, --more, l);
        } else {
            l++;
        }
    }
    return new int[]{less + 1, more - 1};
}

 public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        quickSort(arr, 0, arr.length - 1);
    }

    public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            swap(arr, l + (int) (Math.random() * (r - l + 1)), r); // 大于等于 0.0 且小于 1.0
            int[] p = partition(arr, l, r);
            quickSort(arr, l, p[0] - 1);
            quickSort(arr, p[1] + 1, r);
        }
    }

    public static int[] partition(int[] arr, int l, int r) {
        int less = l - 1;
        int more = r; // 最右的数为基准
        while (l < more) {
            if (arr[l] < arr[r]) {
                swap(arr, ++less, l++);
            } else if (arr[l] > arr[r]) {
                swap(arr, --more, l);
            } else {
                l++;
            }
        }
        swap(arr, more, r);
        return new int[]{less + 1, more};
    }

6. 堆排序

PriorityQueue<Integer> priorityQueue = new PriorityQueue<Integer>(num, new comparator)

1. add()和offer()
   前者在插入失败时抛出异常，后则则会返回false
2. peek()
   获取但不删除队首元素
3. poll()、remove()
   都是获取并删除队首元素，区别是当方法失败时前者抛出异常，后者返回null
4. 比较器用法
   return o1 - o2 升序
   return o2 - o1 降序

public void heapSort(int arr[]) {
    if (arr == null || arr.length < 2) {
        return;
    }
    //O(N*logN)
    //一个一个往数组中添加数字
    for (int i = 0; i < arr.length; i++)//O(N)
        heapInsert(arr, i);  //O(logN)
    //O(N*logN)
    int heapSize = arr.length;
    swap(arr, 0, --heapSize);
    while (heapSize > 0)   //O(N)
    {
        heapify(arr, 0, heapSize);//O(logN)
        swap(arr, 0, --heapSize); //O(1)
    }
}
    public void heapInsert(int arr[], int index) {
        //两个判断条件：
        //1.左孩子或右孩子大于跟结点
        //2.左孩子或右孩子和跟结点相等——到达根部
        while (arr[index] > arr[(index - 1) / 2]) {
            swap(arr, index, (index - 1) / 2); //交换
            index = (index - 1) / 2;
        }
    }
    
    public void heapify(int arr[], int index, int heapSize) {
        int left = index * 2 + 1;  //左孩子的下标
        while (left < heapSize)  //直到下标不能再增加
        {
            //两个孩子谁大 就让谁交换
            //left+1是右孩子下标，如果右孩子越界，就把左孩子下标给largest
            int largest =
                    left + 1 < heapSize && arr[left + 1] > arr[left]
                            ? left + 1 : left;
            //父和较大孩子之间，谁的值大，把下标给largest
            largest = arr[index] > arr[largest] ? index : largest;

            if (largest == index) //当前结点的值就是最大的
            {
                break;
            }
            swap(arr, largest, index);
            index = largest;
            left = index * 2 + 1;
        }
    }

1. 父节点 （index - 1）/ 2
2. 左孩子 index * 2 + 1
3. 右孩子 index * 2 + 1 + 1

7. 计数排序
词频表【数组】，不能太大

8. 基数排序
桶排序