合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
示例 1：
注意这里的0只是占位符，占nums2的位置的
输入：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 中的元素。
（一）利用现成的api
把nums2直接并到nums1后面，然后对nums1用api排序
效率不高
问题：原本已经有序了，合并之后又无序了，所以又排了一遍，这里也能看出快排不适合基本有序
缺点：没有充分利用原本的有序性

public void Merge(int[] nums1, int m, int[] nums2, int n)
        {
            /*用自带的这个效率不高
             * for(int i = 0; i < n; i++)
            {
                nums1[m+i]=nums2[i];
            }
            Array.Sort(nums1);*/
        }

（二）利用有序
双指针改进,但是这里用了个临时空间tmp
时间O(n+m)
空间O(n+m)
原理：双指针+临时存储空间

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LeetCode
{
    public class MergeSortedArray
    {
        public void Merge(int[] nums1, int m, int[] nums2, int n)
        {
            //利用多余的空间temp,双指针n1Index,n2Index比较
            //因为两个数组本身有序，所以比较会出现这几种情况
            //n1中指向的比n2小，n2中指向的比n1小，n1比完了n2还有，n2比完了n1还有
            int k = m + n;
            int[] tmp = new int[m + n];
            for (int index = 0, n1Index=0, n2Index=0; index < k; index++)
            {
                //边界条件，两边都还有,且两边数组不为0
                if( n != 0 && m != 0)
                {
                    if (nums1[n1Index] < nums2[n2Index] && n1Index < m && n2Index < n)
                    {
                        tmp[index] = nums1[n1Index++];
                        //边界条件：两边都还有，且两边数组不为0
                    }
                    else if (nums1[n1Index] >= nums2[n2Index] && n1Index < m && n2Index <  n )
                    {
                        tmp[index] = nums2[n2Index++];
                        //边界条件：一边有一边没有，且两边数组不为0
                    }
                    else if (n1Index >= m && n2Index < n)
                    {
                        tmp[index] = nums2[n2Index++];
                    }
                    //边界条件：一边有一边没有，且两边数组不为0
                    else if (n2Index >= n && n1Index < m )
                    {
                        tmp[index] = nums1[n1Index++];
                        //边界条件：有一边的数组是0，比如n1
                    }
                }
                else//一遍数组有一边数组没有的情况
                {
                    if (n > 0 && m == 0)
                    {
                        tmp[index]=nums2[n2Index++];
                    }
                    //边界条件：有一边的数组是0，比如n2
                    else if (n == 0 && m > 0)
                    {
                        tmp[index]= nums1[n1Index++];
                    }
                }
                  
            }
            nums1 = new int[k];//利用完了nums1，就可以给它重新清空了装tmp
            Array.Copy(tmp, 0, nums1, 0, tmp.Length);
            for (int i = 0; i < nums1.Length; i++)
            {
                Console.WriteLine(nums1[i]);
            }
        }
    }
}

（三）利用本身的n1多出来的三个占位0，利用双指针，不增加多余的空间，倒序（最好的解法）
时间复杂度O（m+n)
空间复杂度O（1）

public void Merge(int[] nums1, int m, int[] nums2, int n)
        {
            int k = m + n - 1;
            for(int index = k, nums1Index = m - 1, nums2Index = n - 1; index >= 0; index--)
            {
                if (m != 0 && n != 0)
                {
                    if (nums1Index >= 0&&nums2Index>=0&&nums1[nums1Index] > nums2[nums2Index])
                    {
                        nums1[index] = nums1[nums1Index--];
                    }
                    else if(nums1Index >= 0 && nums2Index >= 0 && nums1[nums1Index] <= nums2[nums2Index])
                    {
                        nums1[index] = nums2[nums2Index--];
                    }
                    else if (nums1Index < 0 && nums2Index >= 0)
                    {
                        nums1[index] = nums2[nums2Index--];
                    }
                    else if (nums2Index < 0 && nums1Index >= 0)
                    {
                        break;
                    }

                }
                else if (m == 0 && n>0)
                {
                    nums1 = new int[n];
                    if (nums2Index >= 0)
                    {
                        
                        nums1[index] = nums2[nums2Index--];
                    }
                }else if (m>0 && n == 0)
                {
                    break;
                }
            }

            for (int i = 0; i < nums1.Length; i++)
            {
                Console.WriteLine(nums1.Length);
                Console.WriteLine(nums1[i]);
            }
        }