数据结构—单链表C语言刷题1

目录

1.移除链表元素

2.反转链表

3.链表的中间节点

4.链表中倒数第K个节点

5.合并两个有序链表

---

1.移除链表元素

题目链接：https://leetcode-cn.com/problems/remove-linked-list-elements/description/

 

分别定义两个结构体类型指针cur和prev，cur用来遍历链表，prev用来保存cur所在位置的上一个节点的地址，如果cur所在节点的元素不等于所要删除的值，则prev先保存cur所指向节点的地址，再将cur向后走，这样就保证了cur每走到一个节点都能通过prev找到它上一个节点的位置，便于删除元素后的节点之间的链接。找到所要删除元素所在节点后还需要在定义一个结构体变量next，用来存储cur所指向下一个节点的地址，避免直接删除cur所指向的节点后找不到下一个节点的地址，同时也方便链接到cur所指向节点的上一个节点

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

 2.反转链表

题目链接：https://leetcode-cn.com/problems/reverse-linked-list/

方法一： 定义三个结构体指针，tail用来循环原链表，prev用来在tail向后走一步之前存储tail的值，next用来存储tail->next

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* tail = head;
    struct ListNode* prev = NULL;
    while(tail)
    {
        struct ListNode* next = tail->next;
        if(tail->next != NULL)
        {
            tail->next = prev;
            prev = tail;
            tail = next;
        }
        else
        {
            tail->next = prev;
            head = tail;
            tail = next;
        }
    }
    return head;
}

方法二：头插，定义三个结构体变量，cur用来循环遍历原链表，newhead用来表示每一次头插后新的头节点，next用来存储cur->next；

struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* cur = head;
	struct ListNode* newhead = NULL;
	while (cur)
	{
		struct ListNode* next = cur->next;
		cur->next = newhead;
		newhead = cur;
		cur = next;
	}
	return newhead;
}

3.链表的中间节点

题目链接：https://leetcode-cn.com/problems/middle-of-the-linked-list/description/

 

方法一：遍历链表，记录链表总节点数；再遍历链表，循环到总节点数的一半处就是中间节点，返回中间节点的地址

时间复杂度：O(N)

空间复杂度：O(1)

struct ListNode* middleNode(struct ListNode* head){   
    struct ListNode* tail = head;
    struct ListNode* mid = NULL;
    int count = 0;
    while(tail)
    {
        count++;
        tail = tail->next;
    }
    for(int i = 0; i <= (count / 2); i++)
    {
        mid = head;
        head = mid->next;
    }
    return mid;
}

方法二：快慢指针法：定义两个结构体指针，一个快指针fast,一个慢指针slow，快指针一次走两步，慢指针一次走一步，快指针永远都比慢指针快二倍，所以当快指针走到尾或者NULL时，慢指针slow的位置就是中间节点的位置；链表节点为奇数个时，快指针fast走到尾，慢指针slow就是中间节点位置；链表节点为偶数个时，快指针走到NULL时，慢指针slow就是中间节点位置

时间复杂度：O(N)

空间复杂度：O(1)

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow = head;
    struct ListNode* fast = head;
    while(fast && fast->next) //fast的判断必须要放在前面先判断；fast不为空才能判断fast->next 
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;

}

4.链表中倒数第K个节点

题目链接：​​​​​​https://www.nowcoder.com/practice/529d3ae5a407492994ad2a246518148a?tpId=13&&tqId=11167&rp=2&ru=/activity/oj&qru=/ta/coding-interviews/question-ranking

快慢指针法：快指针快指针fast先走k步，然后快指针fast和慢指针slow同时每次走一步，当快指针fast走到NULL时，slow就指向倒数第k个节点位置；与上个题找中间节点的思想类似

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* slow, *fast;
    slow = fast = pListHead;
    while(k--)
    {
        if(fast == NULL)
            return NULL;
        fast = fast->next;
    }
    while(fast)
    {
        fast = fast->next;
        slow = slow->next;
    }
    return slow;  
}

 5.合并两个有序链表

题目链接：https://leetcode-cn.com/problems/merge-two-sorted-lists/

定义一个新的链表，定义其结构体指针newhead作为合并之后链表的头指针，比较list1->val和list2->va，若list1->val小于list2->val，则将list1对应的节点放到新定义的链表之后，再让list1向后走从而进行下一次的比较；若list1->val不小于list2->val，则将list2对应的节点放到新定义的链表之后，再让list2向后走从而进行下一次的比较；因为当list1->val等于list2->val时放其中任意一个到新链表之后都是相同的结果；最后循环走完一定是其中一个链表走到NULL了，若list1先走到NULL了则将list2之后的节点直接链接到新链表之后，因为两个链表都是升序的，合并之后的链表也是升序，所以list2之后的节点元素一定是大于或者等于循环结束时新链表的最后一个节点元素；若list2先走到了NULL,则相反

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){  
    if(list1 == NULL)
        return list2;
    if(list2 == NULL)
        return list1;

    struct ListNode* newhead = NULL, *tail = NULL;

    while(list1 && list2)
    {
        if(list1->val < list2->val)
        {
            if(tail == NULL)
            {
                newhead = list1;
                tail = list1;
            }
            else
            {
                tail->next = list1;
                tail = list1;
            }
            list1 = list1->next;
        }
        else
        {
            if(tail == NULL)
            {
                newhead = list2;
                tail = list2;
            }  
            else
            {          
                tail->next = list2;
                tail = list2;
            }
                list2 = list2->next;            
        }
    }
    if(list2 == NULL)
    {
        tail->next = list1;
    }

    if(list1 == NULL)
    {
        tail->next = list2;
    }
    return newhead;
}

优化上述方法：动态开辟一个哨兵位的头节点的指针为head，这个节点不存储有效数据，有了这个头节点，先将head赋给tail，之后就可以直接将判断之后的节点直接插入到tail之后，这样就减少判断tail为空的情况了；最后要注意head->next就指向的是新链表的头，所以先将tail->next保存起来，再free掉动态开辟的head

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){    
    struct ListNode*tail = NULL;
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->next =NULL;
    tail = head;

    while(list1 && list2)
    {
        if(list1->val < list2->val)
        {
            tail->next = list1;
            tail = list1;
            list1 = list1->next;
        }
        else
        {
            tail->next = list2;
            tail = list2;
            list2 = list2->next;            
        }
    }
    if(list1)
    {
        tail->next = list1;
    }

    if(list2)
    {
        tail->next = list2;
    }

    struct ListNode* list = head->next;
    free(head);
    head = NULL;
    return list;
}