好题分析（2023.10.29——2023.11.04）

目录

​编辑

前情回顾：

前言：

题目一：《合并两个有序数组》

1.运用qsort 

2.利用三指针 

题目二：《移除链表元素》 

题目三：《链表的中间节点》 

总结：

---

前情回顾：

我们在上一篇好题分析中，分析了以下几题：

《消失的数字》《轮转数组》《移除元素》《删除有序数组的重复项》关于时间复杂度的好题分析

上一篇的好题分析的blog在

好题分享（2023.10.22——2023.10.28）-CSDN博客

前言：

本次好题分享，我们将一起来手撕以下三道题，两道关于链表的新内容题，还有一道关于顺序表的题目，接下来让我们手撕！

题目一：《合并两个有序数组》

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

对于该题目，我们给出两种解法。

1.运用qsort 

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);
}

对于该种算法还是较好理解的，先将nums2中的元素放在nums1中，此时我们需要将nums2中的元素放在nums1最后一个元素后面。

放置完后我们再利用qsort排序，此时时间复杂度为O((m+n)log(m+n)) 

2.利用三指针 

 

void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
    int i1 = m-1;
    int i2 = n-1;
    int j = m+n-1;
    while(i1>=0 && i2>=0)
    {
        if(nums1[i1] > nums2[i2])
        {
            nums1[j--] = nums1[i1--];
        }
        else
        {
            nums1[j--] = nums2[i2--];
        }
    }
    
    while(i2>=0)//i1走完，i2还没走完
    {
        nums1[j--] = nums2[i2--];
    }

}

 对于该种算法，我们利用的是三个指针来进行覆盖操作

我们先要来比较i1和i2，谁大，谁就覆盖到j上，同时i1/i2和j同时--。

再接下来，3<5，继续覆盖i2。

 

这时候i1指向的3，则大于i2所指向的2了。所以j被i1覆盖，再同时--。

后面以此类推，我不在这过多赘述了。

但是要注意的是！

如果是以下这种情况：

 

这个时候，毫无疑问i1将会一直走，直到。

 

这个时候，我们就一定要将i2剩下的值，再一个个拷贝进去。这样才是正确答案！

这种时间复杂度为O(N) 

题目二：《移除链表元素》 

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

本题目和下一道题均是在链表上进行算法实现，如果你不懂链表，可以在看完下一篇blog，关于《单链表》的再听一遍。这样便可以更高效的听懂关于本题目的讲解。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode* prev = NULL;
    struct ListNode* cur = head;

    while(cur)
    {
        if(cur->val == val)
        {
            struct ListNode* next = cur->next;
            free(cur);
            if(prev)
            {
                prev->next = next;
            }
            else{
                head = next;
            }
            cur = next;
        }
        else{
            prev = cur;
            cur = cur->next;
        }
    }
    return head;
}

本算法是利用双指针来进行操作，具体实现方法如下：

我们让cur指针先指向头结点，再遍历cur指针，直到cur->val == val，就释放掉该结点

要注意的是后面的val是我们要删掉的值，前面的val是该结点的数据域。

 我们在释放掉cur指向的结点前，一定要再创建一个指针，要指向下一个结点的地址，不然释放该节点后，就会找不到下一个结点的地址。

所以如图所示：

 

再将prev指向的节点的指针域指向next指向结点的指针域。

如此不断往复，就可以得到链表最后的样子。

但是！！

我们一定要想到一种情况，那就是当头节点就是我们要删除的值时，又该是怎么样的处理方式？

即：

 

这种情况就是prev == NULL的时候，意思就是要删除首结点。

那么这个时候，还是一样，创建指针next指向cur下一个结点。

但是这里在free（cur）的时候，还需要将head指向next指向的结点。

意为新的头结点。

 

如此一来，才是完整的代码。

 时间复杂度为O(N)

 

题目三：《链表的中间节点》 

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* middleNode(struct ListNode* head) {
    struct ListNode* slow = head, *fast = head;
    while(fast && fast->next)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}

 这里我们引入一种新算法，也是一种新武器。

“快慢指针”

首先我们先创建两个指针，fast和slow。

fast一次走两步。

slow一次走一步。

再来一次循环

 同时我们要满足，当fast->next == NULL时就要停下，此时停下后，slow的值就是我们需要的中间节点。

还有一种情况

 

 

当fast == NULL时，此时停下后，slow的值就是我们需要的中间值。 

如此一来，就是快慢指针理解的全解析了。

时间复杂度为O(N)

总结：

本次好题分析，我们仅仅讲了三道算法题，难度不大，但是对于我们初学却是一些很有意义的题目，同时也具备很重的含金量，希望大家下来可以多多复习复习。

也可以复习上一篇的好题分享：

好题分享（2023.10.22——2023.10.28）-CSDN博客

记住“坐而言不如起而行”

Action speak louder than words!