排序算法

1.快速排序

public class QuickSort {
    public void sort(int[] nums){
        sort(nums,0,nums.length-1);
    }

    private void sort(int[] nums,int first,int last){
        if(first>=last){
            return;
        }
        int randomIndex = first + new Random().nextInt(last - first + 1);
        swap(nums, randomIndex, first);
        int temp=nums[first];
        int  i=first+1;
        int j=last;
        while(true){
            while(i<nums.length && nums[i]<temp){
                i++;
            }
            while(j>=0 && nums[j]>temp){
                j--;
            }
            if(i>=j){
                break;
            }
            swap(nums,i,j);
            i++;
            j--;

        }
        swap(nums,j,first);
        sort(nums,first,j-1);
        sort(nums,j+1,last);
    }

    private void swap(int[] nums,int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
}

 

2.归并排序

public class MergeSort {
    public void sort(int[] nums){
        sort(nums,0,nums.length-1);
    }
    private void sort(int[] nums,int first,int last){
        if(first>=last){
            return;
        }
        int mid=(first+last)/2;
        sort(nums,first,mid);
        sort(nums,mid+1,last);
        merge(nums,first,mid,last);
    }
    private void merge(int[] nums,int first,int mid,int last){
        int[] temp=new int[last-first+1];
        int i=first;
        int j=mid+1;
        int index=0;
        while(i<=mid && j<=last){
            if(nums[i]<nums[j]){
                temp[index++]=nums[i++];
            }else{
                temp[index++]=nums[j++];
            }
        }
        while(i<=mid){
            temp[index++]=nums[i++];
        }
        while(j<=last){
            temp[index++]=nums[j++];
        }
        for(int k=first;k<=last;k++){
            nums[k]=temp[k-first];
        }
    }
}

 

3.堆排序

public class HeapSort {
    public void sort(int[] nums){
        buildHeap(nums);
        for(int i=nums.length-1;i>0;i--){
            swap(nums,i,0);
            heapify(nums,0,i-1);
        }

    }
    private void buildHeap(int[] nums){
        int maxIndex=0;
        int length=nums.length-1;
        for(int i=length/2;i>=0;i--){
            heapify(nums,i,length);
        }
    }
    private void heapify(int[] nums,int i,int n){
        int maxIndex=0;
        while(2*i+1<=n){
            maxIndex=i;
            if(i*2+1<=n && nums[i*2+1]>nums[maxIndex]){
                maxIndex=i*2+1;
            }
            if(i*2+2<=n && nums[i*2+2]>nums[maxIndex]){
                maxIndex=i*2+2;
            }
            if(i==maxIndex){
                break;
            }
            swap(nums,i,maxIndex);
            i=maxIndex;
        }
    }
    private void swap(int[] nums,int i,int j){
        int temp=nums[i];
        nums[i]=nums[j];
        nums[j]=temp;
    }
}