Quick sort, cluster index, find the k-largest value in the data

Quick sort code

public class Quick {
    
    public static void main(String[] args) {
    
        int [] nums = {
    4,2,4,4,5,1,10,8,6,5,7,100};
        System.out.println(Arrays.toString(nums));
        QuickSort(nums,0,nums.length-1);
        System.out.println(Arrays.toString(nums));
    }

    private static void QuickSort(int[] nums, int beigin, int end) {
    
        if(beigin > end){
    
            return ;
        }
        int i = beigin;
        int j = end;
        int v = nums[beigin];
        while(i < j ){
    
            while(i < j && nums[j]> v){
    
                j--;
            }
            while(i < j && nums[i] <= v){
    
                i++;
            }
            int temp = nums[j];
            nums[j] = nums[i];
            nums[i] = temp;
        }
        nums[beigin] = nums[i];
        nums[i] = v;
        QuickSort(nums,beigin,i-1);
        QuickSort(nums,i+1,end);
    }
}

The difference between clustered index and non clustered index

Cluster index ： An index that has the same sort of index entries as the data records in the table （ Look up Chinese characters with Pinyin in the dictionary ）innodb

Nonclustered indexes ： The index order is different from the physical storage order （ Look up Chinese characters with the partial radicals in dictionary ）myisam

The leaf node of cluster index is the data node , Index and data together .

Dense index and sparse index

Dense index ： Each index key value pair corresponds to an index entry ;

Sparse index ： Only some search code values are indexed ;

The advantages of sparse indexing are ： Smaller footprint , And the maintenance cost is small when inserting and deleting .

Looking for the third in the data k Big value ( Based on fast scheduling )

public class Quic4 {
    
    public int findKthLargest(int[] nums, int k) {
    
        return getKth(nums, 0, nums.length - 1, nums.length - k);
    }

    public int getKth(int[] nums, int start, int end, int k) {
    

        int pivot = nums[start];

        int left = start;
        int right = end;

        while (left < right) {
    

            while (left < right && nums[right] > pivot) {
    
                right--;
            }
            while (left < right && nums[left] <= pivot) {
    
                left++;
            }
            swap(nums, left, right);
        }

        swap(nums, left, start);

        if (k == left) {
    
            return pivot;
        } else if (k < left) {
    
            return getKth(nums, start, left - 1, k);
        } else {
    
            return getKth(nums, left + 1, end, k);
        }
    }

    public void swap(int[] nums, int n1, int n2) {
    
        int tmp = nums[n1];
        nums[n1] = nums[n2];
        nums[n2] = tmp;
    }
}