算法---排序---二分查找法

 

       针对两个有序的数组进行排序：

package com.ghgj.cn.testSort;

import java.util.Arrays;

public class MergeSort01 {

            public static void main(String[] args) {

              int[] arr1={1,3,4,6,8,10};-

              int[] arr2={3,4,6,7,9,10,11,13};

              int[] result = mergeSort(arr1, arr2);

              System.out.println(Arrays.toString(result));

            }

           

            public static int[] mergeSort(int[] arr1,int[] arr2){

             

              //1.创建一个新的数组  长度两个数组长度之和

              int[] newarr=new int[arr1.length+arr2.length];

             

              //2.循环两个数组

              //变量1  记录第一个数组的下标变化

              int m=0;

              //变量2  记录第二个数组的下标变化

              int n=0;

              //变量3  记录新数组的下标变化的  

              int index=0;

             

              //循环  向新数组中添加

              //两个数组都没有到最后的元素的时候 就一直循环比较

              while(m < arr1.length && n < arr2.length){

                 if(arr1[m]<arr2[n]){

                    newarr[index++]=arr1[m++];

                 }else{

                    newarr[index++]=arr2[n++];

                 }

              }

             

              //有可能有一个数组是没有循环完的

              //有可能是第一个数组

              while(m<arr1.length){

                 newarr[index++]=arr1[m++];

              }

             

              //有可能是第二个数组

              while(n<arr2.length){

                 newarr[index++]=arr2[n++];

              }

              return newarr;

            }

}

        针对一个数组进行归并排序：（归并面向的是多个数据集，所以要将数据进行拆分，而后将拆分后的小数据集进行归并排序；什么样的数组一定是有序的：只包含一个元素的数组！）

            拆分规则：从中间的分界线进行逐次拆分，直到每个数组都只包含一个元素，即有序。

            归并规则：将拆分后的数组逐次两两归并，直到恢复成一个数组

            代码：

package com.ghgj.cn.testSort;

import java.util.Arrays;

public class MergeSortFinal {

           public static void main(String[] args) {   

           /*

            * [12, 23, 0, 0, 0, 0, 0, 0]

              [0,0, 1, 12, 0, 0, 0, 0]

                          [12, 1, 23, 12, 0, 0, 0, 0]

              [143, 213, 0, 0, 0, 0, 0, 0]

              [34, 56, 0, 0, 0, 0, 0, 0]

                       [34, 56, 143, 213, 0, 0, 0, 0]

              [23, 12, 12, 1, 143, 213, 34, 56]

            */

           int[] arr={23,12,12,1,143,213,34,56};

           System.out.println(Arrays.toString(arr));

           chai(arr, 0, arr.length-1);

           System.out.println("00000000000000000000000000000000");

           System.out.println(Arrays.toString(arr));

          

           }

           //

           //拆分  left=0   right=3

           public static void chai(int[] arr,int left,int right){

           //找出口

           if(left>=right){

              return;

           }else{

              //mid=1

              int mid=(left+right)/2;

              //递归开始拆

              //拆左半部分

              chai(arr, left, mid);

              //拆右半部分

              chai(arr, mid+1, right);

              //递归并

              int[] mergeSort = mergeSort(arr, mid, left, right);

              System.out.println(Arrays.toString(mergeSort));

           }

           }

          

           //进行归并

           /*

            * 参数：

            * 参数1  原始数组

            * 参数2 分界线

            * 参数3 用于拆分的小数据集的左侧边缘

            * 参数4  用于拆分的小数据集的右侧边缘

            *

            * arr={12,23,1,12,143,213,34,56};

            * {1,12,12,23}

            * newarr={12,23,0,0,0,0,0,0,0,0}

            * mid=1   left=0  right=3

            *

            * 23,12,12,1

            */

           public static int[] mergeSort(int[] arr,int mid,int left,int right){

           //创建一个新数组

           int[] newarr=new int[arr.length];

           //记录变量

           //小数据集1的下标变化的  23  m=0   23 12

           int m=left;

           //小数据集2 的下标变化的   12 n=2   12 1

           int n=mid+1;  

           //新数组的下标变化的   index=0

           int index=left;

           //小数据集1 的边界   x=1

           int x=mid;  

           //小数据集2 的边界   y=3

           int y=right;

           while(m<=x && n<=y){

              //arr[m]=12   arr[n]=1

              if(arr[m]<arr[n]){

                 newarr[index++]=arr[m++];

              }else{

                 //newarr[0]=12  index=1   n=3

                 //newzrr[1]=1  index=2   n=4

                 newarr[index++]=arr[n++];

              }

           }

          

           //小数据集1 还有元素

           while(m<=x){

              //newarr[2]=23   newarr[3]=12

              newarr[index++]=arr[m++];

           }

           //小数据集2  还有元素

           while(n<=y){

              newarr[index++]=arr[n++];

           }

           //将newarr的值  付给arr

           for(int i=left;i<=right;i++){

              arr[i]=newarr[i];

           }

           return newarr;

           }

}