冒泡排序，选择排序，插入排序，归并排序

 1.冒泡排序

冒泡排序的思想，将数组分为已排（右边）和未排（左边）两部分。排序时每次在未排部分从左向右一次比较相邻2个元素，如果左大于右则互换位置。

每次都是指针从左边第一个依次相邻比较，到指针指向倒数第二个未排结束比较。

    @Test
    //冒泡排序
    public void fun4(){
        int[] arr={4,3,2,1,7,90,45,56,34,23,67,67,34,23,13,23};
        int left=0;//数组起始索引
        int right=arr.length-1;//数组末尾索引
        int temp=0;
        for(int i=right;i>left;i--){
            for(int j=left+1;j<=i;j++){
                if(arr[j-1]>arr[j]){
                    temp=arr[j-1];
                    arr[j-1]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

 时间复杂度为O(n^2)，（n为数组元素个数，复杂度为循环执行比较的次数）；

2.选择排序

选择排序思想，将数组分为已排（左边）和未排（右边）两部分。排序时每次在待排部分选择一个最小值并与待排的第一个元素互换，然后已排部分向右扩充一个成员。

    @Test
    //选择排序
    public void fun5(){
        int[] arr={4,3,2,1,7,90,45,56,34,23,67,67,34,23,73,23};
        int left=0;//数组起始索引
        int right=arr.length-1;//数组末尾索引
        for(int i=left;i<right;i++){
            int p=i;
            for(int j=i+1;j<=right;j++){
                if(arr[j]<arr[p]){
                    p=j;
                }
            }
            if(p!=i){
                int temp=arr[i];
                arr[i]=arr[p];
                arr[p]=temp;
            }
        }
        System.out.println(Arrays.toString(arr));
    }

 3.插入排序

插入排序，分为已排（左边）和未排（右边），排序开始时数组第一个元素为已排部分，右边为未排。

    @Test
    //插入排序
    public void fun6(){
        int[] arr={4,3,2,1,7,90,45,56,34,23,67,67,34,23,73,23};
        int left=0;//数组起始索引
        int right=arr.length-1;//数组末尾索引
        for(int i=left+1;i<=right;i++){
            int val=arr[i];//取出待排的第一个
            int j=i;
            while(j >left && val<arr[j-1]){//将待排数据向左（已排数据）依次比较
                arr[j]=arr[j-1];//如果已排数据都大于待排数，将已排数据依次向右位移一位
                j--;
            }
            arr[j]=val;//直到跳出循环将缓存的待排数据放到位移后留下的空位
        }
        System.out.println(Arrays.toString(arr));
    }

 4.归并排序

public class MergeSort {
    //两路归并算法，两个排好序的子序列合并为一个子序列
    public void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];//辅助数组
        int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }
        while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while(p2<=right) tmp[k++]=a[p2++];//同上

        //复制回原素组
        for (int i = left; i <=right; i++) 
            a[i]=tmp[i];
    }
    public void mergeSort(int [] a,int start,int end){
        if(start<end){//当子序列中只有一个元素时结束递归
            int mid=(start+end)/2;//划分子序列
            mergeSort(a, start, mid);//对左侧子序列进行递归排序
            mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
            merge(a, start, mid, end);//合并
        }
    }
    @Test
    public void test(){
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        mergeSort(a, 0, a.length-1);
        System.out.println("排好序的数组：");
        for (int e : a)
            System.out.print(e+" ");
    }
}