21. 合并两个有序链表（归并排序）

目录

合并两个有序链表

题目链接：
​​​https://leetcode-cn.com/problems/merge-two-sorted-lists/​​

解题方法：

• 暴力解法
• 递归
• 迭代
• 归并排序

暴力解法

递归。分治
归并排序 :（Merge Sort）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并, 使用中牺牲空间换取时间的算法 。

//王道课本 
#include<stdio.h>
void Merge(int *A,int *B,int low,int mid,int high){
  int i,j,k;
  for(k=low;k<=high;k++)
    B[k]=A[k];  // 复制A数组 
  for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++){
    if(B[i]<=B[j])
      A[k]=B[i++];
    else
      A[k]=B[j++];
  }
  while(i<=mid)
    A[k++]=B[i++];
  while(j<=high)
    A[k++]=B[j++];   
} 
void MergeSort(int *A,int *B,int low,int high){
  if(low<high){
    int mid=(low+high)/2;
    MergeSort(A,B,low,mid);
    MergeSort(A,B,mid+1,high);
    Merge(A,B,low,mid,high);
  }
}
int main(){
  int a[]={9,8,7,6,5,4,3,2,1};
  int n=sizeof(a)/sizeof(int);
  int i,temp[9];
  printf("原序列为：");
  for(i=0;i<n;i++){
    printf("%d ",a[i]);    
  } 
    printf("\n");
  MergeSort(a,temp,0,n-1);
  printf("\n排序后");
  for(i=0;i<n;i++){
    printf("%d ",a[i]);
  } 
  return 0;  
}

递归的方法

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
     //终止条件，直到两个链表都空
      if(list1==null){
        return list2;
      }else if(list2==null){
        return list1;
      }
      
        else if(list1.val<list2.val){    //注意形参实参
        //递归调用
        list1.next =mergeTwoLists(list1.next,list2);
        return list1;    //注意,这个已经证明，list1的当前值小于list2了，所以就可以直接返回list1了，因为链表只需要一个头节点，就可以找到剩余节点
      }else{
        list2.next = mergeTwoLists(list1,list2.next);
        return list2;
      }
        
    }
}

​​一看就会，一写就废？详解递归（图文描述讲的很好）​​

Leetcode21.+Leetcode75. 归并排序和快速排序的实现

归并排序

视频链接：​​https://www.bilibili.com/video/BV1b7411N798?p=85​​

归并排序的核心操作：如何把数组内两个有序序列归并为一个
通常的二路归并，就是把每一个元素都看成是一个有序序列，
不断合并，最终排序成功

这里定义辅助数组B，等于n，和A的大小是一致的
所以要比堆排序占空间啊，堆排序就不用

B数组只是一个辅助数组，最终的排序结果还是在A上，将归并的结果写到A数组
//low和high指明要排序的范围

package StructDate;

import java.util.Arrays;

public class MergeSort {

    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(int []arr){
        int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间
        sort(arr,0,arr.length-1,temp);
    }

    private static void sort(int[] arr,int left,int right,int []temp){

        if(left<right){

            int mid = (left+right)/2;
            sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序
            sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right,temp);//将两个有序子数组合并操作

        }
    }

    private static void merge(int[] arr,int left,int mid,int right,int[] temp){

        int i = left;//左序列指针
        int j = mid+1;//右序列指针

        int t = 0;//临时数组指针

        while (i<=mid && j<=right){
            if(arr[i]<=arr[j]){
                temp[t++] = arr[i++];
            }else {
                temp[t++] = arr[j++];
            }
        }
        while(i<=mid){//将左边剩余元素填充进temp中
            temp[t++] = arr[i++];
        }
        while(j<=right){//将右序列剩余元素填充进temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        //将temp中的元素全部拷贝到原数组中
        while(left <= right){
            arr[left++] = temp[t++];
        }
    }
}

​​递归的理解​​