数组&链表 快速排序

数组&链表 快速排序

关于思想以及代码别的博客太多了，不做冗余的介绍。

对于数组

public void sort(int[] array, int beg, int end) {
    int index = partition(array, beg, end); //哨兵是也
    sort(array, beg, index - 1); //哨兵左
    sort(array, index + 1, end); //哨兵右分别递归sort方法
    /* 要知道上面的递归写法都是针对整个数组的，对于寻找第k小的数得这么写 */
    /*while (beg < end) {
        int index = partition(nums, beg , end);
        if (index > k - 1)
            end = index - 1;
        else if (index < k - 1)
            beg = index + 1;
        else
            break;
    }
    return nums[k - 1];*/
}

private int partition(int[] array, beg, end) {
    int key = array[beg]; //beg做关键字
    while (beg < end) {
        while (array[end] >= key && beg < end) {
            end--;
        }
        array[beg] = array[end];
        while (array[beg] <= key && beg < end) {
            beg++;
        }
        array[end] = array[beg];
    }
    array[end] = key;
    return end;
}

对于链表

public void sort(ListNode head, ListNode end) {
    if (head != end) {
        ListNode mid = partition(head, end);
        sort(head, mid);
        sort(mid.next, end);
    }
}

public ListNode partition(ListNode head, ListNode end) {
    if (head.next == null)
        return head;
    ListNode p = head;
    ListNode q = head.next;
    int key = p.val;
    while (q != end) { //注意这里跟数组排序有点不一样
        if (q.val < key) {
            p = p.next; //p作为慢指针想找比key小的跟他交换，好狡猾
            swap_val(p, q);
        }
        q = q.next;
    }
    swap_val(head, p); //最后把head扔到哨兵的位置
    return p; //返回哨兵
}

关于链表

关于链表还想说一件事——归并排序，顺便总结一下

public ListNode sortList(ListNode head) {
    if (head == null || head.next == null)
        return head;
    ListNode mid = getMid(head); //得到中间的函数，很关键，很机智
    ListNode rHead = mid.next;
    mid.next = null; //把尾巴清空
    return merge(sortList(head), sortList(rHead));//左半边右半边递归
}

private ListNode getMid(ListNode head) {
    if (head.next.next == null)
        return head;
    ListNode slow, fast;
    slow = fast = head; //快慢指针，快指针越界了就说明慢指针到正中间
    while (fast.next != null && fast.next.next != null) {/*注意这里是next的next*/
        slow = slow.next;
        fast = fast.next.next;
    }
    return slow;
}

private ListNode merge(ListNode head, ListNode rHead) {
        ListNode dummy = new ListNode(0);
        ListNode cur = dummy;
        /* 这里就相当于合并两个已排序的链表，是不是很机智？ */
        while (head != null && rHead != null) {
            if (head.val < rHead.val) {
                cur.next = head;
                head = head.next;
            } else {
                cur.next = rHead;
                rHead = rHead.next;
            }
            cur = cur.next;
        }

        if (head == null) {
            cur.next = rHead;
        } else
            cur.next = head;

        return dummy.next;
    }