归并排序(思路分析+疑惑解析)

 

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

 

 

合并的时候思路

 

package sort;

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
    /**
     * (1)临时数组的作用？
     * 归并排序需要一个额外空间 在合并的时候需要排序比较大小,则将比较过的有序的序列放到temp中，并将temp中数据填充到原数组中
     * 优化 :一次性定义一个数组，避免了在合并的时候多次新建数组，避免不必要的开销
     *
     * (2)归并排序的时候是否将数组真正分成一个一个的小数组?
     *并不是,只是逻辑上将其分割,right和left的指向
     *
     * (3)将temp数组的元素拷贝到arr,是否每次将所有元素都拷贝进去
     * 注意,并不是每次都拷贝所有 比如第一次
     * 第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
     * 最后一次 tempLeft = 0  right = 7
     *
     * (4)左右递归结束的条件?
     * left < right 如果相等,说明分的该数组中只有一个元素了,该合并了
     * */
public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {8,4,5,7,1,3,6,2,1};
        //int[] arr = new int[8000000];
        /*for(int i =  0;i <arr.length ;i++ ){
            arr[i] =(int)Math.random()*8000000;
        }*/

        System.out.println("排序前");
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
        String date1Str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间是 = "+date1Str);

        int[] temp = new int[arr.length];
        //归并排序需要一个额外空间 在合并的时候需要排序比较大小,则将比较过的有序的序列放到temp中，并将temp中数据填充到原数组中
        //优化 ：一次性定义一个数组，避免了在合并的时候多次新建数组，避免不必要的开销
        mergeSort(arr,0,arr.length-1,temp);

        System.out.println("排序后");
        Date date2 = new Date();
        String date2String = simpleDateFormat.format(date2);
        System.out.println("排序后的时间是 = "+date2String);

        System.out.println("归并排序后 ="+ Arrays.toString(arr));

    }
    public static void mergeSort(int[] arr,int left,int right,int[] temp){


        if(left < right){//递归结束条件
            int mid = (left + right)/2; //中间索引
            //向左递归进行分解
            mergeSort(arr,left,mid,temp);
            //向右递归进行分解
            mergeSort(arr,mid+1,right,temp);
            //合并
            merge(arr,left,mid,right,temp);
        }
    }

    //合并的方法
    /**
     *
     * @param arr 排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp 做中转的数组
     */
    public static void merge(int[] arr,int left,int mid,int right,int[] temp){

        int i = left; // 初始化i, 左边有序序列的初始索引
        int j = mid+1;//初始化j, 右边有序序列的初始索引
        int t = 0 ;// 指向temp数组的当前索引

        //(一)
        //先把左右两边(有序)的数据按照规则填充到temp数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while (i <= mid && j <= right){
            //如果左边的有序序列的当前元素，小于等于右边有序序列的元素
            //将左边的当前元素，填充到temp数组中
            //然后t++,i++ 指向下一个元素
            if(arr[i] < arr[j]){
                temp[t] = arr[i];
                t += 1;
                i += 1;
            }else{//反之, 将右边的当前元素，填充到temp数组中
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }
        //(二)
        //把有剩余数据的一边的数据依次全部填充到temp
        while (i <= mid){//左边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }
        while (j <= left){//右边的有序序列还有剩余的元素，就全部填充到temp
            temp[t] = arr[j];
            t += 1;
            i += 1;
        }

        //(三)
        //将temp数组的元素拷贝到arr
        //注意,并不是每次都拷贝所有 比如第一次

        t = 0;
        int tempLeft = left;
        //第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
        //最后一次 tempLeft = 0  right = 7
        System.out.println("tempLeft = "+tempLeft+" right = "+right);
        while (tempLeft <= right){
            arr[tempLeft] = temp[t];
            t += 1;
            tempLeft += 1;
        }
    }
}

归并排序模板

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;//递归结束条件 数组分到只剩下一个元素的时候，就结束该层递归，返回上一层 

    int mid = l + r >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);

	// i = 0是错误的  
	//因为在递归的过程中 l , r ,mid在递归过程中是在不断变化的 
	//初始化的时候,不能写死,写成固定的值 
    int k = 0, i = l, j = mid + 1;
    while (i <= mid && j <= r)
        if (q[i] <= q[j]) 稳定排序,需要加上等号  
			tmp[k ++ ] = q[i ++ ];
        else 
			tmp[k ++ ] = q[j ++ ];

    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

	//	for( i = 0 ; i <= r ;i++){
	//		q[i] = temp[i];
	//	}
	
	//第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
    //最后一次 tempLeft = 0  right = 7
	//在递归的过程中 l是不断变化的,不能写成上面那种 
    for (i = l, j = 0; i <= r; i ++, j ++ ) 
		q[i] = tmp[j];
}

完整代码

#include<iostream>
using namespace std;
using namespace std;

const int N = 1e6+10;
int n;
int tmp[N];//临时数组用来每次 排序的时候临时存放  最后还要放回原数组中 
int q[N];

void merge_sort(int q[], int l, int r)
{
    if (l >= r) return;//递归结束条件 数组分到只剩下一个元素的时候，就结束该层递归，返回上一层 

    int mid = l + r >> 1;
    merge_sort(q, l, mid);
    merge_sort(q, mid + 1, r);

	// i = 0是错误的  
	//因为在递归的过程中 l , r ,mid在递归过程中是在不断变化的 
	//初始化的时候,不能写死,写成固定的值 
    int k = 0, i = l, j = mid + 1;
    while (i <= mid && j <= r)
        if (q[i] <= q[j]) 稳定排序,需要加上等号  
			tmp[k ++ ] = q[i ++ ];
        else 
			tmp[k ++ ] = q[j ++ ];

    while (i <= mid) tmp[k ++ ] = q[i ++ ];
    while (j <= r) tmp[k ++ ] = q[j ++ ];

	//	for( i = 0 ; i <= r ;i++){
	//		q[i] = temp[i];
	//	}
	
	//第一次合并 tempLeft = 0 , right = 1 //  tempLeft = 2  right = 3 // tL=0 ri=3
    //最后一次 tempLeft = 0  right = 7
	//在递归的过程中 l是不断变化的,不能写成上面那种 
    for (i = l, j = 0; i <= r; i ++, j ++ ) 
		q[i] = tmp[j];
}

int main(){
	
	scanf("%d",&n);
	for(int i = 0 ; i < n ; i++){
		scanf("%d",&q[i]);
	}
	merge_sort(q,0,n-1);
	 for(int i = 0 ; i < n ; i++){
		printf("%d ",q[i]);
	}
	
}