几种排序

1.mergeSort O(nlogn)的时间复杂度，需要O(n)的额外空间。

public void sortIntegers2(int[] A) {
        // Write your code here
        if (A == null || A.length == 0) {
            return ;
        }
        int[] temp = new int[A.length];
        mergeSort(A, 0, A.length - 1, temp);
    }
    
    private void mergeSort(int[] A, int start, int end, int[] temp) {
        if (start == end) {
            return ;
        }
        int mid = start + (end - start) / 2;
        mergeSort(A, start, mid, temp);
        mergeSort(A, mid + 1, end, temp);
        merge(A, start, mid, end, temp);
    }
    
    private void merge(int[] A, int start, int mid, int end, int[] temp) {
        int index = start;
        int left = start;
        int right = mid + 1;
        while(left <= mid && right <= end) {
            if (A[left] < A[right]) {
                temp[index++] = A[left++];
            } else {
                temp[index++] = A[right++];
            }
        }
        while (left <= mid) {
            temp[index++] = A[left++];
        }
        while (right <= end) {
            temp[index++] = A[right++];
        }
        for (int i = start; i <= end; i++) {
            A[i] = temp[i];
        }
    }

2.quickSort O(nlogn)的时间复杂度，需要O(1)的额外空间

public void sortIntegers2(int[] A) {
        // Write your code here
        if (A == null || A.length == 0) {
            return ;
        }
        quickSort(A, 0, A.length - 1);
    }
    
    private void quickSort(int[] A, int start, int end) {
        if (start >= end) {
            return ;
        }
        int pivot = getPivot(A, start, end);
        int i = start;
        int j = end;
        while (i <= j) {
            while (i <= j && A[i] < pivot) {
                i++;
            }
            while (i <= j && A[j] > pivot) {
                j--;
            }
            if (i <= j) {
                swap(A, i, j);
                i++;
                j--;
            }
        }
        quickSort(A, start, j);//Attention
        quickSort(A, i, end);//Attention
    }
    
    private int getPivot(int[] A, int start, int end) {
        Random random = new Random();
        int index = random.nextInt(end - start + 1);
        return A[start + index];
    }
    
    private void swap(int[] A, int i, int j) {
        int temp = A[i];
        A[i] = A[j];
        A[j] = temp;
    }

3.insertionSort O(n^2)的时间复杂度， 需要O(1)的额外空间。

private void insertionSort(int[] A) {
        for (int p = 1; p < A.length; p++) {
            int j;
            int temp = A[p];
            for (j = p; j > 0 && A[j - 1] > temp ; j--) {
                    A[j] = A[j - 1];
            }
            A[j] = temp;
        }
    }

4.Insertion Sort List O(n^2)时间复杂度，需要O(1)的额外空间

链表插入排序

真是尴尬，开始时受到数组插入排序的影响，总想着从有序部分的后面开始寻找插入位置，还想着怎么搞一个指向前边的指针，定式思维的危害啊。。。

其实从有序部分的前边开始寻找插入位置就可以了嘛

需要注意的是：

dummy.next 并没有指向head，有序部分的最后一个节点指向的是null，这就可以作为每轮插入的一个循环控制条件。

public ListNode insertionSortList(ListNode head) {
        ListNode dummy = new ListNode(0);
        while (head != null) {
            ListNode node = dummy;
            while (node.next != null && node.next.val < head.val) {
                node = node.next;
            }
            ListNode temp = head.next;
            head.next = node.next;
            node.next = head;
            head = temp;
        }
        return dummy.next;
    }

5.归并排序

public ListNode sortList(ListNode head) {
        return mergeSort(head);
    }
    public ListNode mergeSort(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode middle = findMiddle(head);
        ListNode right = middle.next;
        middle.next = null;
        ListNode left = mergeSort(head);
        right = mergeSort(right);
        return merge(left, right);
    }
    public ListNode merge(ListNode left, ListNode right) {
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        while (left != null && right != null) {
            if (left.val < right.val) {
                tail.next = left;
                tail = left;
                left = left.next;
            } else {
                tail.next = right;
                tail = right;
                right = right.next;
            }
        }
        tail.next = left == null ? right : left;
        return dummy.next;
    } 
    public ListNode findMiddle(ListNode head) {
        ListNode right = head;
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode left = dummy;
        while (right != null && right.next != null) {
            right = right.next.next;
            left = left.next;
        }
        return left;
    }

6.单项链表冒泡排序

public static ListNode bubbleSort(ListNode head) {
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        ListNode cur = head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        ListNode prev = dummyHead;
        for (int i = count; i > 0; i--) {
            prev = dummyHead;
            cur = prev.next; // Attention!
            int j = 0;
            while (j < i - 1) {
                if (cur.val > cur.next.val) {
                    ListNode temp = cur.next.next;
                    prev.next = cur.next;
                    cur.next.next = cur;
                    cur.next = temp;
                }
                prev = prev.next;
                cur = prev.next;
                j++;
            }
        }
        return dummyHead.next;
    }