它的工作原理是将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序是不稳定的排序方法，最差时间复杂度和冒泡排序是一样的都是O(n^2)，它的平均时间复杂度为O(n*log2n)，空间复杂度为O(log2n)~O(n)
步骤拆解：
(1)先选择一个基数（比如我们这里选择第一个数5作为基数），先从右往左找一个小于5的数，再从左往右找一个大于5的数，然后交换他们。
（这里我们将两个变量分别称为i和j ,注意，j先开始走），j从数据的最右端开始找比5小的一个数据，找到了4，然后i再从左往右找一个大于5的数，找到了8，两者交换
屏幕快照 2019-03-04 下午4.11.01.png
(2)第一次交换结束，i停留在了4，j停留在了8，然后开始第二次的交换，j继续往左边找比5小的一个数据，找到了3，然后i再从左往右找一个大于5的数，没有找到，遇到了j，i和j相遇，第一轮排序结束。然后将基数5和3进行交换
屏幕快照 2019-03-04 下午4.45.47.png
(3)现在基数5已经归位，它处在序列的第6位。此时我们已经将原来的序列以5为分界点拆分成了两个序列，左边的序列是“3 3 4 0 1”，右边的序列是“6 8 9 6”。接下来还需要分别处理这两个序列。因为5左边和右边的序列目前都还是很混乱的。
屏幕快照 2019-03-04 下午4.51.35.png
(4) 这里首先处理左边的序列，将这个序列以3为基数进行调整，使得3左边的数都小于等于3，3右边的数都大于等于3
屏幕快照 2019-03-04 下午4.55.50.png
(5)一直重复上述操作，直到不可拆分出新的子序列为止
func quickSort(list:Array<Int> , startIndex:Int, lastIndex:Int) -> Array<Int>
{
var arr = list
let temp = arr[startIndex]
var i = startIndex
var j = lastIndex
while i < j {
while (i<j && arr[j] >= temp) {
j = j - 1
}
while (i<j && arr[i] <= temp) {
i = i + 1
}
if (i != j)
{
let t = arr[i]
arr[i] = arr[j]
arr[j] = t
}
}
arr[startIndex] = arr[i]
arr[i] = temp
if (i-startIndex > 1)
{
arr = quickSort(list: arr, startIndex: startIndex,lastIndex:i-1)
}
if (lastIndex - i > 1)
{
arr = quickSort(list: arr, startIndex: i+1,lastIndex:lastIndex)
}
return arr
}
let list = [5,3,8,0,1,3,6,4,9,6]
print(quickSort(list:list , startIndex: 0,lastIndex:list.count-1))
