常见的排序算法

插入算法

从第二个数开始往前插入，如果遇到比当前值小则往后移，最终再也找不到比当前数（tmp）小或者小于0则将tmp放到j+1中（因为j-- 会多减一次）

public void insertSort(int nums[]){
        for(int i=1;i<nums.length;i++){
            int tmp=nums[i];
            int j=i-1;
            for(;j>=0&&nums[j]>tmp ;j--){
                nums[j+1]=nums[j];
            }
            nums[j+1]=tmp;
        }
    }

冒泡算法

简单来说就是每次冒泡一个最大的值，每次都能找到一个数放在他该在的位置所以n个数只需要找n-1次。第一层循环是确定循环多少次，第二层就是从头开始找剩下数中最大的。

public void bubbleSort(int nums[]){
        for(int i=0;i<nums.length-1;i++){
            boolean flag =true;
            for(int j=1;j<nums.length-i;j++){
                if(nums[j-1]>nums[j]){
                    swap(nums,j-1, j);
                    flag=false;
                }
            }
            if(flag==true){
                break;
            }
        }
    }

分治算法

第一步先从中间分开，直到每个小组都分到至少两个元素开始进行排序。

/**
     * megesort
     * @param nums
     */
    public void  mergesort(int nums[],int l,int r){
        if(l>=r)return;
        int mid=(l+r)/2;
        mergesort(nums, l, mid);
        mergesort(nums,mid+1, r);
        merge(nums,l,mid,r);

    }
    public void merge(int nums[],int l,int mid,int r){
        int tmp[]=new int[r-l+1];
        int i=l,j=mid+1,idx=0;
        while(i<mid+1&&j<r+1){
            if(nums[i]<nums[j]){
                tmp[idx++]=nums[i++];
            }else{
                tmp[idx++]=nums[j++];
            }
        }
        while(i<mid+1){
            tmp[idx++]=nums[i++];
        }
        while(j<r+1){
            tmp[idx++]=nums[j++];
        }
        for(int k=0;k<tmp.length;k++){
            nums[l+k]=tmp[k];
        }
    }

堆排序

首先先建堆
1.从最后一个非叶子节点开始，也就是（len-1)/2网上调整，知道把最大的冒上去，然后再依次往后进行相同的操作。
2.得到最大堆后，把堆头拿下来放到数组后面，再继续进行建立最大堆的过程。

 public void headsort(int nums[]){
        for(int i=(nums.length-1)/2;i>=0;i--){
            buildhead(nums, i, nums.length-1);
        }
        int end=nums.length-1;
        while(end>0){
            swap(nums, end,0 );
            end--;
            buildhead(nums, 0, end);
        }
    }
    public void buildhead(int nums[],int i,int r){
        int child=2*i+1;
        while(child<=r){
            int lson=child;
            int rson=child+1;
            if(rson<=r&&nums[rson]>nums[lson]){
                child++;
            }
            if(nums[i]<nums[child]){
                swap(nums, i, child);
            }else{
                break;
            }
            i=child;
            child=2*i+1;
        }
    }

快速排序

/**
     * 快速排序
     * @param
     */
    public void qsort(int arr[],int start,int end){
        if(start>=end)return;
        int l=start,r=end;
        int tmp=arr[start];
        while(l<r){
            while(l<r&&arr[r]>=tmp)r--;
            arr[l]=arr[r];
            while(l<r&&arr[l]<=tmp)l++;
            arr[r]=arr[l];
        }
        arr[l]=tmp;
        qsort(arr, start, l);
        qsort(arr, l+1, end);
    }

希尔排序

其实就是分组版本的插入排序算法，并且他的分组是从大到小的分隔的，大小到一的时候就有序了

public void shellsort(int nums[]){
        for(int gap=nums.length/2;gap>0;gap/=2){
            for(int i=0;i<gap;i++){
                for(int j=i+gap;j<nums.length;j+=gap){
                    if(nums[j]<nums[j-gap]){
                        int k;
                        int tmp=nums[j];
                        for(k=j-gap;k>=0&&nums[k]>tmp;k-=gap){
                            nums[k+gap]=nums[k];
                        }
                        nums[k+gap]=tmp;
                    }
                }
            }
        }
    }
}