数据结构与算法期末复习第三天

算法部分

合并两个有序数组

原题

给你两个按 非递减顺序 排列的整数数组 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 中。
 

提示：

nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[j] <= 109

进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

思路

开辟一个新的m+n的数组，归并两个小数组，从头比较两个数组的值，将两个数组里面的数据从后向前依次比较，将最大的依次从后向前放到nums1中。

步骤：

1.首先将两个数组种最后面的数据进行比较，取较大的放到dst的位置。
2.如果是nums1中的数大，将i1的数赋给dst，然后再将i1–，再与nums2进行比较。
3.相反，如果是nums2中的数大，将i2的数赋给电视台，然后再将i2–，再与nums1进行比较。
4.到最后，如果是nums2先结束，那就不用处理，因为剩下的数本来就是nums1里面的。
5.如果是nums1先结束，那就要将nums2中剩下的数挪到nums1中。

代码实例

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n){
    int i1 = m-1; //nums1的数组长度
    int i2 = n-1; //nums2的数组长度   
    int dst = m+n-1; //总的数组长度
    //取大的给过去
    while(i1>=0  && i2>=0)
    {
        if(nums1[i1] > nums2[i2]) //判断如果nums1的数大那么移到新数组中
            nums1[dst--] = nums1[i1--];
        else
            nums1[dst--] = nums2[i2--];
    }

    //如果是nums2先结束，那就不用处理了，因为剩下的数本来就是nums1中的

    //如果是nums1先结束，nums2中的元素有剩余，那就需要将nums2中剩下的数挪过去
    while(i2>=0)
    {
        nums1[dst--] = nums2[i2--];
    }

}

移除链表元素

原题

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6
输出：[1,2,3,4,5]
示例 2：

输入：head = [], val = 1
输出：[]
示例 3：

输入：head = [7,7,7,7], val = 7
输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

思路

我的思路就是判断链表中是否有与val相同的数，如果相同则删除，不同则保留

如何让head指针往下移动呢？

设置一个指针

我的想法就是迭代

第一种方式：递归

第二种方式：迭代

代码实例

//第一种方式：递归
struct ListNode* removeElements(struct ListNode* head, int val) {
    if (head == NULL) {
        return head;
    }
    head->next = removeElements(head->next, val);
    return head->val == val ? head->next : head; 
}

//第二种方式：迭代
struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode* dummyHead = malloc(sizeof(struct ListNode));
    dummyHead->next = head;
    struct ListNode* temp = dummyHead;
    while (temp->next != NULL) {
        if (temp->next->val == val) {
            temp->next = temp->next->next;
        } else {
            temp = temp->next;
        }
    }
    return dummyHead->next;
}

删除链表中的节点

原题

有一个单链表的 head，我们想删除它其中的一个节点 node。

给你一个需要删除的节点 node 。你将 无法访问 第一个节点  head。

链表的所有值都是 唯一的，并且保证给定的节点 node 不是链表中的最后一个节点。

删除给定的节点。注意，删除节点并不是指从内存中删除它。这里的意思是：

• 给定节点的值不应该存在于链表中。
• 链表中的节点数应该减少 1。
• node 前面的所有值顺序相同。
• node 后面的所有值顺序相同。

自定义测试：

• 对于输入，你应该提供整个链表 head 和要给出的节点 node。node 不应该是链表的最后一个节点，而应该是链表中的一个实际节点。
• 我们将构建链表，并将节点传递给你的函数。
• 输出将是调用你函数后的整个链表。
   

示例 1：

 

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：指定链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9
示例 2：

输入：head = [4,5,1,9], node = 1
输出：[4,5,9]
解释：指定链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9

提示：

链表中节点的数目范围是 [2, 1000]
-1000 <= Node.val <= 1000
链表中每个节点的值都是 唯一 的
需要删除的节点 node 是 链表中的节点 ，且 不是末尾节点

思路

我的思路：感觉就是查找是否与node相同，相同就删除。

但是需要注意的是删除操作是将要删除的数字变成另一个数字后再删除。

引用 力扣评论区 一个很有意思的评论来解释说明：这道题细思极恐：如何让自己在世界上消失，但又不死？ —— 将自己完全变成另一个人，再杀了那个人就行了。

有一点脑筋急转弯，但是并不难写 ^_^

代码实例

void deleteNode(struct ListNode* node) {
            node->val = node->next->val;   
            node->next = node->next->next;  
}

 未来的复习算法时间线

（综合考虑本人期末考试重点和复习时间点）

 大概会按照这个复习计划走，再结合一些固定的算法，灵活变通，噜噜啦啦