快速排序

实现原理

快速排序思想：如果要排数组p到r之间的一组数据，选择p到r之间任意一个一个数据作为pivot（分区点，这里选择的是s[r]作为pivot）。遍历p到r之间的数据，将小于pivot的数据放在左边，其他的放右边。经过这一步骤后数据p到r被分成了三份，前面p～q-1的数据小于pivot，q+1~r的数据大于pivot。接着递归分治实现剩下子分区的排序。

如下图所示是一次分区的结果，以数组的最后一个节点4作为pivot:

 

代码实现(golang)

package main

import "fmt"

func quicklySort(s []int) []int {
    quickylySortImpl(s, 0, len(s)-1)
    return s
}

func quickylySortImpl(s []int, p, r int) {
    if p >= r {
        return
    }
    q := partition(s, p, r)
    quickylySortImpl(s, p, q-1)
    quickylySortImpl(s, q+1, r)
}

func partition(s []int, p, r int) int {
    pivot := s[r]
    i := p
    for j := p; j <= r; j++ {
        if s[j] < pivot {
            s[i], s[j] = s[j], s[i]
            i = i + 1
        }
    }
    s[i], s[r] = s[r], s[i]
    return i
}

func main() {
    fmt.Println(quicklySort([]int{7, 10, 2, 3, 6, 1, 4}))
}

程序运行输出 1，2，3，4，6，7，10

时间复杂度O(nlogn), 空间复杂度O(1)

扩展应用

O(n)时间复杂度求数组的第K大数据

package main

import "fmt"

func findKthLargest(nums []int, k int) int {
    q := findKthLargestImpl(nums, 0, len(nums)-1, k)
    return nums[q]
}

func findKthLargestImpl(nums []int, p, r, k int) int {
    if p >= r {
        return p
    }
    q := partition(nums, p, r)
    fmt.Println("pq=", q)
    if (q + 1) == k {
        fmt.Println("q=", q)
        return q
    } else if (q + 1) < k {
        q = findKthLargestImpl(nums, q+1, r, k)
    } else {
        q = findKthLargestImpl(nums, p, q-1, k)
    }
    return q
}

func partition(s []int, p, r int) int {
    pivot := s[r]
    i := p
    for j := p; j <= r; j++ {
        if s[j] > pivot {
            s[i], s[j] = s[j], s[i]
            i = i + 1
        }
    }
    s[i], s[r] = s[r], s[i]
    return i
}
func main() {
    fmt.Println(findKthLargest([]int{3, 2, 1, 5, 6, 4}, 2))
}

程序运行输出 5

需要特别注意的是程序32行由大于号变成了小于号，即把比pivot大的数据放左边，让数据从大到小，从而符合第K大的判断要求。如果求第K小则不用动。

第一遍运行数组的排序是 5， 6，4，3，2，1  q = 2即元素4，进入了代码第24行的逻辑 findKthLargestImpl(nums, 0, 1, 2)

第二遍运行数组的排序是 6，5，4，3，2，1  q = 0即元素6，进入了代码第20行的逻辑 findKthLargestImpl(nums, 1, 1, 2)

第三遍运行直接返回1,即元素5