Leetcode 【88】 合并两个有序数组 C语言

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

解法一

借助辅助空间的双指针

//双指针借助辅助空间
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    //malloc堆上申请辅助空间
    int *temp = (int*)malloc(sizeof(int) * (m+n));
    //判空
    if(NULL == temp){
        return;
    }
    int i = 0;
    int j = 0;
    int count = 0;
    //对应下标比较把小的插进temp
    while(i < m && j < n){
        if(nums1[i] >= nums2[j]){
            temp[count++] = nums2[j++];
        }
        else {
            temp[count++] = nums1[i++];
        }
    }
    //nums1 或者 nums2 某一个已经全部放进去的结果
    while(j < n){
      temp[count++] = nums2[j++];
    }
     while(i < m){
   temp[count++] = nums1[i++];
    }
    //最后放到num1中 或者用循环放进去
   memcpy(nums1,temp,sizeof(int)*(m+n));
   free(temp);
}

解法二

逆向双指针没有借助辅助空间

把空间复杂度降低下来了

//逆向双指针没有借助辅助空间
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    int end1 = m - 1;
    int end2 = n - 1;
    int count = m + n - 1;
    //从尾巴开始比较往前放 跟刚刚那个是一个思路
    while(end1 >= 0 && end2 >= 0 ){
        if(nums2[end2] >= nums1[end1]){
            nums1[count--] = nums2[end2--];
        }
        else{
            nums1[count--] = nums1[end1--];
        }
    }
    while(end1 >= 0){
        nums1[count--] = nums1[end1--];
    }
    while(end2 >= 0){
        nums1[count--] = nums2[end2--];
    }
}

解法三 

直接合并借助qsort这个内置函数进行快速排序

//模拟比较函数
int Compare1(const void* xp, const void* yp) {
	int x = *(const int*)xp;
	int y = *(const int*)yp;
	if (x > y) {
		return 1;
	}
	else if (x < y) {
		return -1;
	}
	else {
		return 0;
	}
}
//自己的那个比较函数函数
int Compare2(const void* xp, const void* yp){
    int* x = (const int *)xp;
    int* y = (const int *)yp;
    return *x - *y;//升序排列
    //升序排列时，若第一个参数指针指向的“值”大于第二个参数指针指向的“值”，则返回正；
    //若第一个参数指针指向的“值”等于第二个参数指针指向的“值”，则返回零；
    //若第一个参数指针指向的“值”小于第二个参数指针指向的“值”，则返回负。
}
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 就完事了
    //qsort参数:排序数组 ，排序数组长度 ，元素大小，函数指针
    //这里面涉及到了回调函数
    qsort(nums1, nums1Size, sizeof(int), Compare2);
}

qsorst的模拟实现

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <assert.h>
void Showarr(int* arr, int num) {
	for (int i = 0; i < num; i++) {
		printf(" %d ", arr[i]);
	}
}
int Compint(const void* xp, const void* yp) {
	int x = *(const int*)xp;
	int y = *(const int*)yp;
	if (x > y) {
		return 1;
	}
	else if (x < y) {
		return -1;
	}
	else {
		return 0;
	}
}
void Swap(char* curr, char* next, size_t size) {
	while (size) {
		char temp = *curr;
		*curr = *next;
		*next = temp;
		curr++, next++, size--;
	}
}
void MyQsort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*)) {
	assert(base != NULL);
	assert(compar != NULL);
	char* start = (char*)base;
	for (size_t i = 0; i < num - 1; i++) {
		int flag = 0;
		for (size_t j = 0; j < num - 1 - i; j++) {
			if (compar(start + j * size, start + (j + 1) * size) > 0) { 
				Swap(start + j * size, start + (j + 1) * size, size);
				flag = 1;
			}
		}
		if (flag == 0) {
			break;
		}
	}
 
}
int main() {
	int arr[] = { 12,354,54,123,-123,-32,453,1,4,5,1312 };
	int num = sizeof(arr) / sizeof(arr[0]);
	Showarr(arr ,num);
	printf("\n");
	MyQsort(arr,num,sizeof(int),Compint);
	Showarr(arr, num);
}