Java排序算法

1.冒泡排序

思路： 数组长度N，从i=1->N,依次比较两个相邻的元素，将值第i大的元素交换至右端。
时间复杂度：O(n^2) 空间复杂度: O(1)

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

2. 插入排序

思路： 保证待插入的值前面的数据是排好序的，再就待插入的值依次比较插入。
时间复杂度：O(n^2) 空间复杂度: O(1)

      public static void InsertSort(int[] arr) {
        for (int i=1;i<arr.length;i++){
            //要插入的数据
            int temp=arr[i];
            int j=i;
            while (j>0&&temp<arr[j-1]){
                arr[j]=arr[j-1];
                j--;
            }
            if (j!=i){
                arr[j]=temp;
            }
        }

    }

3. 归并排序

**分治思想：**分解子问题：拆分成独立子数组，子问题求解：子数组排序，合并问题解：合并
时间复杂度：O(nlog(n)) 空间复杂度: O(n)

   public static void MergeSort(int[] arr,int start, int end) {
        int middle=(start+end)/2;
        //递归的重复条件
        if (start<end) {
            MergeSort(arr,start,middle);
            MergeSort(arr,middle+1,end);
            Merge(arr,start,middle,end);
        }
    }

    public static void Merge(int[] arr, int start, int middle, int end) {
        //创建临时数组存放排序好的数据
        int[] temps = new int[end - start + 1];
        int i=start;
        int j=middle+1;
        int index=0;
        while (i<=middle && j<=end){
            if (arr[i]<=arr[j]){
                temps[index]=arr[i];
                i++;
            }else {
                temps[index]=arr[j];
                j++;
            }
            index++;
        }
        //第二个数组已经比较完
        while (i<=middle){
            temps[index]=arr[i];
            i++;
            index++;
        }
        //第一个数组已经比较完
        while (j<=end){
            temps[index]=arr[j];
            j++;
            index++;

        }
       for (int k=0;k<temps.length;k++){
           arr[start+k]=temps[k];
       }

    }

4. 快速排序

分治思想： 与归并不同，快速排序侧重分解简化合并；设置一个主元，保证主元左边的数均比他小，右边的数均比他大，同理拆分子数组。
时间复杂度：O(nlog(n)) 空间复杂度: O(log(n))

 /**
     * 最差情况O(n2) 每次数值划分后，主元都在一侧
     * 最好情况O(nlogn) 每次数值划分后，主元都在中间
     * @param arr
     * @param start
     * @param end
     */
    public static void QuickSort(int[] arr,int start,int end){
        if (start>end) return;
        //选取主元,先取最右边的数值为主元
        int X=arr[end];
        int i=start-1;
        //如果arr[j]<=x 交换arr[j]和arr[i+1],j,i右移
        //如果arr[j]>x,j右移
        int temp;
        for (int j=start;j<=end-1;j++){
            if (arr[j]<=X){
                temp = arr[i + 1];
                arr[i+1]=arr[j];
                arr[j]=temp;
                i++;
            }
        }
        //最后将主元放在i+1位置上
        temp=arr[i+1];
        arr[i+1]=X;
        arr[end]=temp;
        QuickSort(arr,start,i);
        QuickSort(arr,i+2,end);
    }

5.桶排序

思想：桶排序原理是将数组分到有限数量的桶里。每个桶再个别排序，每个桶里面数据再排序,桶排序非常快但是也非常消耗空间，典型的以空间换时间，基本上是最耗内存的一种排序算法。通常情况下，比快排和归并快。
当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间O(n),空间复杂度O(n)

 public void BucketSort(int[] arr){
        int buckegtnum=10;
        int index=0;
        LinkedList<Integer>[] B = new LinkedList[buckegtnum];
        for (int i = 0; i < buckegtnum; i++) {
            B[i]=new LinkedList<Integer>();
        }
        for (int i = 0; i < arr.length; i++) {
            int b = arr[i] / buckegtnum;
            B[b].add(arr[i]);
        }
        for (int i = 0; i < buckegtnum; i++) {
            Collections.sort(B[i]);
        }
        for (int i = 0; i < buckegtnum; i++) {
            while (B[i].peek()!=null){
                arr[index++]=B[i].poll();
            }
        }
        
    }

6. 选择排序

**思路：**将未排序序列中找到最小元素，存放到排序序列的末尾。
时间复杂度：O(n^2) 空间复杂度: O(1)

public static void SelectSort(int[] arr) {
        //遍历arr-1次
        for (int index=0;index<arr.length-1;index++){

            int min=index;

            //寻找最小的值
          for (int i=index+1;i<arr.length-1;i++){
              //寻找最小的值下标
                if (arr[i]<arr[min]){
                    min=i;
                }
          }
          if (min!=index){
              int tmp=arr[index];
              arr[index]=arr[min];
              arr[min]=tmp;
          }

        }

    }