八大排序--快速排序

##一、快速排序
###基本思想
选择一个基准元素，通常选择第一个或者最后一个元素，通过一趟扫描， 将待排序的元素分成两部分，一部分比基准元素小， 一部分大于或等于基准元素，此时基准元素在起排好序的位置，然后用同样的方法递归地排序划分的两部分
###实例：

###代码实现

package com.chb.sort;
/**
 *	选择一个基准， 通常为第一个元素或最后一个元素， 
 *  通过一趟扫描， 将带排序的序列分成两部分， 
 *  	比基准元素小    基准元素 	比基准元素大或等于
 *  **此时基准元素正好在排好序的正确位置**
 *  然后同样的方式**递归**的对两部分进行排序
 *  
 */
public class MyQuickSort {
	public void  quickSort() {
		 int a[]={49,38,65,97,76,13};
		_quickSort(a, 0, a.length-1);
	}
	/**
	 * 递归的对两部分进行排序，
	 * @param a2    待排序的序列
	 * @param low  排序的开始位置
	 * @param high      结束位置
	 * @return
	 */
	public void  _quickSort(int[] a2, int low, int high) {
		int middle = getMiddle(a2, low, high);
		_quickSort(a2, low, middle-1);
		_quickSort(a2, middle+1, high);
	}
	/**
	 * 获取基准元素在排好序的序号
	 * @param a
	 * @param low
	 * @param high
	 * @return
	 */
	public int getMiddle(int[] a, int low, int high) {
		//设置基准元素， 取第一个元素为基准元素
		int tmp = a[low];
		while(low < high) {
			//拿基准元素到最后一个元素开始比较
			while (low < high && a[high] > tmp) {
				high--;
			}
			//比基准元素小的放在索引小的地方， 更换其位置
			a[low] = a[high];
			
			while (low < high && a[low] < tmp) {
				low++;
			}
			a[high] = a[low];
		}
		//经过比较之后， low=high, 本轮比较结束 ， 将基准元素放在正确的位置。
		a[low] = tmp;
		return low;//返回其序号。以便递归比较基准元素两边的部分。
	}
	public static void main(String[] args) {
	 MyQuickSort myQuickSort = new MyQuickSort();
	 myQuickSort.quickSort();
	}
}

###执行出现了Exception in thread “main” java.lang.StackOverflowError

好像有时候对象相互引用死循环会出这个异常
堆栈溢出，简单地说就是死循环了

python实现

class Solution:
    def largestPerimeter(self, A: List[int]) -> int:
        self.quickSort(A, 0, len(A)-1)
        print(A)
        for i in range(len(A)-1, 1, -1):
            if A[i] < A[i-1] + A[i-2]:
                return A[i] + A[i-1] + A[i-2]
        
        
    def quickSort(self, arr: List[int], low: int, high: int) -> None:
        middle = self.getMiddle(arr, low, high)
        # 减少递归次数
        if low < middle:
            self.quickSort(arr, low, middle-1)
        if high > middle:
            self.quickSort(arr, middle+1, high)
    
    def getMiddle(self, arr: List[int], low: int, high: int) ->int:
        tmp = arr[low]
        while low < high:
            # 从高位开始寻找比tmp小的值
            while low < high and arr[high] >= tmp:
                high -= 1
            
            # 将高位的小于tmp值 放到地位
            if low < high:
                arr[low] = arr[high]
                low += 1
                
            # 从低位开始寻找比tmp大的值
            while low < high and arr[low] <= tmp:
                low += 1
            
            # 将高位的小于tmp值 放到地位
            if low < high:
                arr[high] = arr[low]
                high -= 1
        arr[low] = tmp
        return low