JavaDS--归并排序、冒泡排序

归并排序

原理：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使
子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并
合并两个有序数组、一个数组分成两部分，两部分都有序
[left,mid) [mid,right)
在排序过程中重复利用两个数组，减少元素的复制过程
合并了两个有序数组：

    public static void mergeDate(int[] arrar,int left,int mid,int right ,int[] tmp){
        int index=left;
        int begin1=left,end1=mid,begin2=mid,end2=right;
        while(begin1<end1 && begin2<end2){
            if (arrar[begin1] <= arrar[begin2]) {
                tmp[index++]=arrar[begin1++];
            }else{
                tmp[index++]=arrar[begin2++];
            }
        }
        //如果第一个区间中还有数据
        while (begin1<end1){
            tmp[index++]=arrar[begin1++];
        }
        //如果第二个区间有数据
        while (begin2<end2){
            tmp[index++]=arrar[begin2++];
        }
    }

归并排序实现：

    public static void mergeSort(int[] array,int left,int right,int[] tmp){
        //优化，在right-left<16时，可以使用插入排序
        if(right-left>1){
            int mid=left+((right-left)>>1);
            //左半部分
            mergeSort(array,left,mid,tmp);
            //右半部分
            mergeSort(array,mid,right,tmp);
            //归并
            mergeDate(array,left,mid,right,tmp);
            //System.out.println(Arrays.toString(tmp));
            //归并结束后，有序序列存储在tmp中
            //将tmp中的数据拷贝到array中去
            System.arraycopy(tmp,left,array,left,right-left);
        }
    }

循环实现归并排序：
开始将每个数字当成一个数组序列，两个相邻数组序列进行合并排序

    public static void mergeSortNor(int[] array){
        int[] tmp=new int[array.length];
        int gap=1;
        while(gap<array.length){
        	//第一次循环，合并成第一行的形式
        	//第一次循环，合并成第二行的形式
        	//...以此类推
            for(int i=0;i<array.length;i+=gap*2){
				//第一次循环，第一、二个数字进行排序
				//第二次循环，第三、四个数字进行排序
				//....类推
                int left=i;
                int mid=left+gap;
                int right=mid+gap;
                //防止越界
                if(mid>array.length){
                    mid=array.length;
                }
                if(right>array.length){
                    right=array.length;
                }
                mergeDate(array,left,mid,right,tmp);
            }
            System.arraycopy(tmp,0,array,0,array.length);
            gap=gap<<1;
        }
    }

冒泡排序

原理：
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序
时间复杂度：
最好：O(N)----->数据有序
平均：O(N^2)
最坏：O(N^2)----->数据逆序
空间复杂度：O(1)
稳定性：稳定
实现代码：

    public static void BobbleSort(int[] arr){
        //用来优化冒泡---冒泡一定趟数后就已经有序了，后序的冒泡就不需要冒了
        //如果已经有序，在冒泡是肯定不需要元素的交换了
        boolean isChange=false;
        //外层循环控制冒泡的趟数
        for (int i=0;i<arr.length-1;i++){
            //具体冒泡的方式
            //一趟冒泡 的方式，让相邻的两个元素进行比较
            //让大的元素往后移动
            isChange=false;
            for(int j=1;j<arr.length-i;j++){
                if(arr[j-1]>arr[j]){
                    swap(arr,j-1,j);
                    isChange=true;
                }
            }
            if(isChange=false){
                return;
            }
        }
    }