好题分析（2023.10.29—

好题分析（2023.10.29——2023.11.04）

news2024/11/27 11:33:03

编辑

前情回顾：

前言：

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

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一次走一步。