最最最重要的Java的排序算法

package lbr.Alano;
//注释一定要写，不要删
import java.util.Arrays;

public class Sort {

    public static void main(String[] args) {
        int[] str= {1,5,9,8,6,3,7,2};
        //冒泡排序
        //BubblingSort(str);

        //选择排序
        //SelectSort(str);

        //快速排序
        //QuickSort(str,0,str.length-1);

         归并排序
         mergeSort(str,0,str.length-1);
        //两种输出
        //System.out.println(Arrays.toString(str));
        for (int i : str) {
            System.out.print(i+" ");
        }

    }

/*
 * 
（1）稳定性
     　归并排序是一种稳定的排序。
（2）存储结构要求
    　可用顺序存储结构。也易于在链表上实现。
（3）时间复杂度
    　对长度为n的文件，需进行趟二路归并，每趟归并的时间为O(n)，故其时间复杂度无论是在最好情况下还是在最坏情况下均是O(nlgn)。
（4）空间复杂度
   　 需要一个辅助向量来暂存两有序子文件归并的结果，故其辅助空间复杂度为O(n)，显然它不是就地排序。
  注意：
    　若用单链表做存储结构，很容易给出就地的归并排序
 */
    private static void mergeSort(int[] str, int left, int right) {
        if (left<right) {
            int mid=(left+right)/2;
            mergeSort(str, left, mid);
            mergeSort(str, mid+1, right);
            merge(str,left,mid,right);
        }
        
    }
    private static void merge(int[] str, int left, int mid, int right) {
         int[] temp=new int[str.length];
         int templeft=left;
         int tempmid=mid+1;
         int flag=left;
         while (templeft<=mid&&tempmid<=right) {
            if (str[templeft]<=str[tempmid]) {
                temp[flag++]=str[templeft++];
            }else {
                temp[flag++]=str[tempmid++];
            }
        }
         while (templeft<=mid) {
            temp[flag++]=str[templeft++];
        }
         while (tempmid<=right) {
            temp[flag++]=str[tempmid++];
        }
        for (int i = left; i <=right; i++) {
            str[i]=temp[i];
        }
    }

    //快速排序
    private static void QuickSort(int[] str, int l, int h) {
        if(l<h) {
            int mid=getmid(str,l,h);
            QuickSort(str, l, mid-1);
            QuickSort(str, mid+1, h);
        }
        
    }
    //获取中间值
    private static int getmid(int[] str, int l, int h) {
        int temp=str[l];
        while (l<h) {
            while (l<h&&temp<=str[h]) {
                h--;
            }
            str[l]=str[h];
            str[h]=str[l];
            while (l<h&&temp>=str[l]) {
                l++;
            }
            str[h]=str[l];
            str[l]=temp;    
        }
        return l;
    }

    //选择排序
    private static void SelectSort(int[] str) {
        for (int i = 0; i < str.length-1; i++) {
            for (int j = i; j < str.length-i-1; j++) {
                if(str[j]>str[j+1]) {
                    int temp=str[j]^str[j+1];
                    str[j]=str[j]^temp;
                    str[j+1]=str[j+1]^temp;
                }
            }
        }
        
    }
    //冒泡排序 比较相邻的俩个，大的向后，小的向前，每一层找出一个最大的数放在最后，下一次继续寻找。
    private static void BubblingSort(int[] str) {
        for (int i = 0; i < str.length-1; i++) {
            for (int j = 0; j < str.length-i-1; j++) {
                if(str[j]>str[j+1]) {
                    int temp=str[j]^str[j+1];
                    str[j]=str[j]^temp;
                    str[j+1]=str[j+1]^temp;
                }
            }
        }
    }

}