排序算法(冒泡，快排，归并）

冒泡排序：（从小到大）

1.比较相邻元素，若第一个元素比第二个大，就交换两个

2.对相邻元素做同样步骤，从第一对元素到最后一对元素，直到最后的元素最大

3.对所有元素重复以上步骤，除了最后一个；

重复步骤1-3，直到排序完成

public static void sort(int w[])
{
    for(int i=0;i<w.length-1;i++)
    {
        for(int j=0;j<w.length-1-i;j++)
        {
            if(w[j]>w[j+1]){
            int t = w[j];
            w[j] = w[j+1];
            w[j+1]=t;
        }
    }
}

选择排序：（在剩余的元素中不断找到最大（小）值）

找到最大（小）的元素

再将它和数组的第一个元素交换位置

再从剩余的元素中找到最大（小）的元素，将它与数组的第二个元素交换位置重复以上步骤，

public static void sort(int[] arr)
{
    int k=0;
    for(int i=0;i<arr.length;i++)
    {
        k=i;
        for(int j=i+1;j<arr.length;j++)
        {
            if(arr[k]>arr[j])k=j;
        }
        if(k!=i)
        {
            int tmp = arr[i];
            arr[i]  = arr[k];
            arr[k] = temp;
        }
    }
}

插入排序：（适用于部分有序的数组，也适合于小规模数组）

对未排序数据，在已排序序列中从后向前扫描，找到相应位置插入，插入位置之后的元素都要相应往后移动一位

   public  static void sort(int[] arr){
        for(int i=1;i<arr.length;i++){
            int key = arr[i];
            int j= i-1;
            while(j>=0 && arr[j]>key){
                arr[j+1] = arr[j];
                j--;
            }
            arr[j+1] = key;
        }
    }

快速排序：

选择一个基准数，比它大的数放在其右边，比它小的数放在其左边，在对这两边进行同样的操作（递归进行）既可以进行排序

public int[] Array(int[] nums){
    quicksort(nums,0,nums.length-1);
    return nums;
}

public void quicksort(int[] nums,int start,int end){
    int random =getRandom(nums,start,end);
    swap(nums,start,random);
    int left= start,right=end;
    while(left<right){
        
    }
}

希尔排序：

按照增量进行排序，之后缩小增量继续分组排序，直到增量减少到1时，整个文件被分为一组，再次排序完成整个数组的排序

    public  static int[] sort(int[] nums){
        for(int format =nums.length/2;format>0;format/=2){
            for(int i= format;i<nums.length;i++){
                int j =i;
                int tmp =nums[j];
                if(nums[j]<nums[j-format]){
                    while(j- format>=0 && tmp<nums[j-format]){
                        nums[j] =  nums[j-format];
                        j-=format;
                    }
                    nums[j]=tmp;
                }
            }
        }
        return nums;
    }

归并排序：

先拆分再合并

利用递归与分治技术将数组划分为最小的子表，对子表排序后用递归的方法进行合并

先分治再合并：

    public void merge(int[] nums,int left,int right){
        if(left==right)return;
        int mid = left+((right-left)>>1);
        merge(nums,left,mid);
        merge(nums,mid+1,right);
        sort(nums,left,mid,right);
    }

排序：

    public void sort(int[] nums,int left,int mid,int right){
        int[] arr = new int[right-left+1];
        int i=left,j=mid+1,k=0;
        while(i<=mid && j<=right){
            arr[k++] =  nums[i]<=nums[j]?nums[i++]:nums[j++];
        }
        while(i<=mid)arr[k++]=nums[i++];
        while(j<=right)arr[k++]=nums[j++];
        for(i=0;i<k;i++){
            nums[i+left] = arr[i];
        }
    }

计数排序：

1.找到最大最小值；

2.定义合适的数组，统计元素出现的频率；

3.输出结果