合并两个有序数组（力扣刷题记录）

目录

方法一：直接合并后排序

C语言：qsort 快速排序函数

Java：Arrays.sort 排序函数

python3/python:sort 排序

---

方法一：直接合并后排序

C语言：qsort 快速排序函数

调用方法：

qsort(nums,numsSize,sizeof(int),cmp)

nums : 数组的首地址一般为数组名（数组定义成 int* nums）
numsSize: 数组中的元素个数
sizeof(数据类型)
cmp:排序方式（分为递增跟递减）

递增排序

int cmp(int* a,int* b){
    return *a-*b;
}

递减排序

int cmp(int* a,int* b){
    return *b-*a;
}

使用案例（合并两个有序数组）

int cmp(int* a,int* b){
    return *a-*b;
}

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
   for(int i=0;i!=n;++i){
       nums1[m+i]=nums2[i];
   }
   qsort(nums1,nums1Size,sizeof(int),cmp);
}

Java：Arrays.sort 排序函数

 static void sort(ElementType[] a)  ：默认为升序排序
 static void sort(ElementType[] a, int FromIndex, int ToIndex)  ：在指定范围（FromIndex, ToIndex）内升序排序
 

使用案例

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
          for(int i=0;i!=n;++i){
              nums1[m+i]=nums2[i];
          }
          Arrays.sort(nums1);
    }
}

python3/python:sort 排序

list.sort() ：对列表进行原地从小到大排序 （字母和数字都可以）

list.sort(reverse=True) ：对列表进行从大到小排序

companies.sort(key=sort_key, reverse=True) ：对列表中的关键字key进行从大到小排序

使用案例：

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        nums1[m:]=nums2
        nums1.sort()

方法二：双指针（用临时变量）

给两个数组设置指针，对指针所指的数进行比较，小的进入数组，指针后移，继续比较，直到没有位置可移动。

C语言：

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
    int p1 = 0, p2 = 0;
    int sorted[m + n];
    int cur;
    while (p1 < m || p2 < n) {
        if (p1 == m) {
            cur = nums2[p2++];
        } else if (p2 == n) {
            cur = nums1[p1++];
        } else if (nums1[p1] < nums2[p2]) {
            cur = nums1[p1++];
        } else {
            cur = nums2[p2++];
        }
        sorted[p1 + p2 - 1] = cur;
    }
    for (int i = 0; i != m + n; ++i) {
        nums1[i] = sorted[i];
    }
}

Java：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
         int p1=0,p2=0;
         int[] sorted=new int[m+n];
         int cur;
         while(p1<m ||p2<n){
             if(p1==m){
                 cur=nums2[p2++];
             } else if(p2==n){
                 cur=nums1[p1++];
             } else if(nums1[p1]<nums2[p2]){
                 cur=nums1[p1++];
             }else{
                 cur=nums2[p2++];
             }
             sorted[p1+p2-1]=cur;
         }
         for(int i=0;i!=m+n;++i){
             nums1[i]=sorted[i];
         }
    }
}

Python：

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        sorted=[]
        p1,p2=0,0
        while p1<m or p2<n:
            if p1==m:
                sorted.append(nums2[p2])
                p2+=1
            elif p2==n:
                sorted.append(nums1[p1])
                p1+=1
            elif nums1[p1]<nums2[p2]:
                sorted.append(nums1[p1])
                p1+=1
            else:
                sorted.append(nums2[p2])
                p2+=1
        nums1[:]=sorted

方法三：逆向双指针

直接移到第二个数组中可能会使第二个数组中的数据被覆盖，因此需要临时变量来存数据，但是从后面插入便不会。

C语言：

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
    int p1 = m - 1, p2 = n - 1;
    int tail = m + n - 1;
    int cur;
    while (p1 >= 0 || p2 >= 0) {
        if (p1 == -1) {
            cur = nums2[p2--];
        } else if (p2 == -1) {
            cur = nums1[p1--];
        } else if (nums1[p1] > nums2[p2]) {
            cur = nums1[p1--];
        } else {
            cur = nums2[p2--];
        }
        nums1[tail--] = cur;
    }
}

java:

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p1 = m - 1, p2 = n - 1;
        int tail = m + n - 1;
        int cur;
        while (p1 >= 0 || p2 >= 0) {
            if (p1 == -1) {
                cur = nums2[p2--];
            } else if (p2 == -1) {
                cur = nums1[p1--];
            } else if (nums1[p1] > nums2[p2]) {
                cur = nums1[p1--];
            } else {
                cur = nums2[p2--];
            }
            nums1[tail--] = cur;
        }
    }
}

 python:

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        p1, p2 = m - 1, n - 1
        tail = m + n - 1
        while p1 >= 0 or p2 >= 0:
            if p1 == -1:
                nums1[tail] = nums2[p2]
                p2 -= 1
            elif p2 == -1:
                nums1[tail] = nums1[p1]
                p1 -= 1
            elif nums1[p1] > nums2[p2]:
                nums1[tail] = nums1[p1]
                p1 -= 1
            else:
                nums1[tail] = nums2[p2]
                p2 -= 1
            tail -= 1

以上代码来源于力扣。