快速排序&堆排序

1.快速排序

import java.util.*;
public class Main{
    public static void main(String[] args) {  
        int[] nums={5,2,3,6,4,1};
        int len=nums.length;
        sort(nums,0,len-1);
        for(int i=0;i<len;i++){
            System.out.println(nums[i]);
        }
    }
    public static void sort(int[] nums,int start,int end){
        if(start>=end){
            return;
        }
        int index=start;
        int left=start;
        int right=end;
        while(left<=right){
            while(left<=right && nums[right]>=nums[index]){
                right--;
            }
            if(left<=right){
                swap(nums,index,right);
                index=right;
            }
            while(left<=right && nums[left]<=nums[index]){
                left++;
            }
            if(left<=right){
                swap(nums,index,left);
                index=left;
            }
        }
        sort(nums,0,index-1);
        sort(nums,index+1,end);
    }
    public static void swap(int[] nums,int a,int b){
        int temp=nums[a];
        nums[a]=nums[b];
        nums[b]=temp;
    }
}

2.堆排序

import java.util.*;
public class Test{
    public static void main(String[] args) {
        int[] nums={4,5,2,3,8,1};
        int len=nums.length;
        for(int i=len/2;i>=0;i--){
            adjustHeap(nums,i,len-1);
        }
        for(int i=len-1;i>0;i--){
            swap(nums,0,i);
            adjustHeap(nums,0,i-1);
        }
        for (int i=0;i<len;i++){
            System.out.println(nums[i]);
        }
    }
    public static void adjustHeap(int[] nums,int parent,int len){
        int temp=nums[parent];
        int child=2*parent+1;
        while(child<=len){
            if(child+1<=len && nums[child+1]>nums[child]){
                child++;
            }
            if(nums[child]>temp){
                nums[parent]=nums[child];
                parent=child;
                child=child*2+1;
            }else{
                break;
            }
        }
        nums[parent]=temp;
    }
    public static void swap(int[] nums,int start,int end){
        int temp=nums[start];
        nums[start]=nums[end];
        nums[end]=temp;
    }
}

 

3.求第K大的数（利用快速排序每次缩小范围减小k）

import java.util.*;
public class Main{
    public static void main(String[] args) {  
        int[] nums={5,2,3,6,4,1};
        int k=4;
        int len=nums.length;
        System.out.println(getK(nums,0,len-1,k));
    }
    public static int getK(int[] nums,int start,int end,int k){
        if(k==1){
            int res=nums[start];
            for(int i=start+1;i<=end;i++){
                if(nums[i]>res){
                    res=nums[i];
                }
            }
            return res;
        }else{
            int index=start;
            int left=start;
            int right=end;
            while(left<=right){
                while(left<=right && nums[right]>=nums[index]){
                    right--;
                }
                if(left<=right){
                    swap(nums,index,right);
                    index=right;
                }
                while(left<=right && nums[left]<=nums[index]){
                    left++;
                }
                if(left<=right){
                    swap(nums,index,left);
                    index=left;
                }
            }
            int size=end-index;
            if(size==k-1){
                return nums[index];
            }else if(size>=k)
            {
                return getK(nums,index+1,end,k);
            }else{
                return getK(nums,start,index-1,k-size-1);
            }
        }
    }
    public static void swap(int[] nums,int a,int b){
        int temp=nums[a];
        nums[a]=nums[b];
        nums[b]=temp;
    }
}

4.求第K大的数（利用堆排序维护K的小顶堆）

import java.util.*;
public class Main{
    public static void main(String[] args) {  
        int[] nums={5,2,3,6,4,1};
        int k=3;
        int len=nums.length;
        int[] heap=new int[k];
        for(int i=k/2;i>=0;i--){
            heapAdjust(heap,0,k-1);
        }
        for(int i=k;i<len;i++){
            if(nums[i]<=heap[0]){
                continue;
            }else{
                int temp=heap[0];
                heap[0]=nums[i];
                heapAdjust(heap,0,k-1);
            }
        }
        System.out.println(heap[0]);
    }
    public static void heapAdjust(int[] nums,int parent,int len){
        int temp=nums[parent];
        int child=parent*2+1;
        while(child<len){
            if(child+1<len && nums[child+1]<nums[child]){
                child++;
            }
            if(temp<nums[child]){
                break;
            }
            nums[parent]=nums[child];
            parent=child;
            child=child*2+1;
        }
        nums[parent]=temp;
    }
}