两个有序数组合并成一个有序数组

思想：先依次比较两个数组，按照小的就传入新的数组。当这次比较完之后可能有一个数组的长度很长，留下一些数组，然后在新数组的末尾插入即可。

代码：

public class ArraySort {  
  
    public static void main(String[] args) {  
        int[] a = {1,3,4};  
        int[] b = {2,3,5,6};  
          
        int[] c = mergeArray(a, b);  
          
        for(int n : c){  
            System.out.print(n+" ");  
        }  
    }  
      
    //合并数组  
    public static int[] mergeArray(int[] a , int[] b){  
        int result[] = new int[a.length + b.length];  
          
        if(checkSort(a) && checkSort(b)){  
            //说明ab数组都是有序的数组  
            //定义两个游标  
            int i=0,j=0,k=0;  
              
            while(i<a.length && j<b.length){  
                if(a[i] <= b[j]){  
                    result[k++] = a[i++];  
                }else{  
                    result[k++] = b[j++];  
                }  
            }  
              
            while(i < a.length){  
                //说明a数组还有剩余  
                result[k++] = a[i++];  
            }  
              
            while(j < b.length){  
                result[k++] = b[j++];  
            }  
        }  
          
        return result;  
          
    }  
      
    //检查一个数组是否是有序的  
      
    // 1 2 3  
    public static boolean checkSort(int[] a){  
        boolean flag = false;//默认不是有序的  
          
        for(int i=0;i<a.length-1;i++){  
            if(a[i] > a[i+1]){  
                //说明不是有序的  
                flag = false;  
                break;  
            }else{  
                flag = true;  
            }  
        }  
          
        return flag;  
    }  
}  

归并排序

归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。值得注意的是归并排序是一种稳定的排序方法。速度仅次于快速排序，为稳定排序算法，一般用于对总体无序，但是各子项相对有序的数列

    public class MergingSort {  
      
        public static void sort(int[] data, int left, int right) {  
            if (left < right) {  
                // 首先找出中间的索引  
                int center = (left + right) / 2;  
      
                // 对中间索引左边的数组进行递归  
                sort(data, left, center);  
      
                // 对中间索引右边的数组进行递归  
                sort(data, center + 1, right);  
                // 合并  
                merge(data, left, center, right);  
            }  
        }  
      
        public static void merge(int[] data, int left, int center, int right) {  
      
            int[] tmpArr = new int[data.length];  
      
            int mid = center + 1;  
      
            // third记录中间数组的索引  
            int third = left;  
      
            int tmp = left;  
      
            while (left <= center && mid <= right) {  
                // 将两个数组中取出最小的数放入中间数组  
                if (data[left] <= data[mid]) {  
                    tmpArr[third++] = data[left++];  
                } else {  
                    tmpArr[third++] = data[mid++];  
                }  
            }  
      
            // 剩余部分依次放入中间数组  
            while (mid <= right) {  
                tmpArr[third++] = data[mid++];  
            }  
      
            while (left <= center) {  
                tmpArr[third++] = data[left++];  
            }  
              
            while(tmp <= right){  
                data[tmp] = tmpArr[tmp++];  
            }  
        }  
      
        public static void main(String[] args) {  
            int[] a = { 3, 2, 5, 4 };  
              
            sort(a, 0, a.length - 1);  
      
            for (int i = 0; i < a.length; i++) {  
                System.out.print(a[i] + " ");  
            }  
        }  
    }