牛客网做的快排练习题，说我31行代码数组越界，这个哪里越界的啊大哥们

有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。
给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。
说这一行代码数组越界int mid = partition(a,left,right);

case通过率为0.00%
Exception in thread "main" java.lang.StackOverflowError
at Finder.quickSort(Finder.java:31)

import java.util.*;

public class Finder {

    //交换方法
    public void swap(int []a,int l,int r){                 
        int temp;
        temp = a[r];
        a[r] = a[l];
        a[l] = temp;
    }

    //一次快排
    public int partition (int []a, int left ,int right){
        while(left<right){
            while(left<right&&a[right]>a[left]){
                right--;
            }
            if(left<right)
                swap(a,left,right);
            while(left<right&&a[left]<a[right]){
                left++;
            }
            if(left<right)
                swap(a,left,right);
        }
        return left;
    }
    //快排算法
    public void quickSort(int[]a ,int left, int right ){
        int mid = partition(a,left,right);
        quickSort(a,left,mid-1);
        quickSort(a,mid+1,right);
    }
    public int findKth(int[] a, int n, int K) {
        // write code here
        quickSort(a,0,n-1);
        return a[K-1];

        }
    }

quickSort自身递归调用了，无法退出，相当于死循环

代码就不仔细看了，错误太多，快排、分区都不对，直接参考下面的吧

 /******************************************************* 
     *快速排序 (比较排序类) 
     *每次排序将待排记录分割两部分,一部分都比关键字小,一部分都比关键字大 
     ********/  
    public void quickSort(int[] L) {          
        Qsort(L,1,L.length-1);  
    }  

    public void Qsort(int[] L,int low,int high) {  
        int pivot;  
        if(low<high) {  
            //将L[low,high]一分为二,算出枢轴值pivot,该值得位置固定,不用再变化   
            pivot=partition0(L,low,high);  

            //对两边的数组分别排序  
            Qsort(L,low,pivot-1);  
            Qsort(L,pivot+1,high);            
        }                 
    }  

    //  选择一个枢轴值(关键字) 把它放到某个位置 使其左边的值都比它小 右边的值都比它大  
    public int partition0(int[] L,int low,int high) {  
        int pivotkey;  
        pivotkey=L[low];  
        //顺序很重要，要先从右边找
        while(low<high) {  
            while(low<high && L[high]>=pivotkey) {  //从后往前找到比key小的放到前面去  
                high--;  
            }  
            swap(L,low,high);     
            while(low<high && L[low]<=pivotkey) {  //从前往后找到比key大的 放到后面去  
                low++;  
            }  
            swap(L,low,high);  
        } //遍历所有记录  low的位置即为 key所在位置, 且固定,不用再改变  
        return low;  
    }  
 //交换数组的两个位置  
    public void swap(int[] L,int i,int j) {  

        int temp=L[i];  
        L[i]=L[j];  
        L[j]=temp;  

    }