[数据结构与算法] 链表

最新推荐文章于 2022-12-04 20:47:11 发布

南方以北

最新推荐文章于 2022-12-04 20:47:11 发布

阅读量382

点赞数 1

分类专栏：数据结构算法

本文链接：https://blog.csdn.net/qq_25800311/article/details/88855797

版权

算法同时被 2 个专栏收录

69 篇文章 36 订阅

订阅专栏

数据结构

53 篇文章 15 订阅

订阅专栏

针对链表的插入、删除操作，需要对插入第一个结点和删除最后一个结点的情况进行特殊处理。这样代码实现起来就会很繁琐，不简洁，而且也容易因为考虑不全而出错。如何来解决这个问题呢？

技巧三中提到的哨兵就要登场了。哨兵，解决的是国家之间的边界问题。同理，这里说的哨兵也是解决“边界问题”的，不直接参与业务逻辑。如果我们引入哨兵结点，在任何时候，不管链表是不是空，head 指针都会一直指向这个哨兵结点。我们也把这种有哨兵结点的链表叫带头链表。相反，没有哨兵结点的链表就叫作不带头链表。哨兵结点是不存储数据的。因为哨兵结点一直存在，所以插入第一个结点和插入其他结点，删除最后一个结点和删除其他结点，都可以统一为相同的代码实现逻辑了。

我经常用来检查链表代码是否正确的边界条件有这样几个：

如果链表为空时，代码是否能正常工作？

如果链表只包含一个结点时，代码是否能正常工作？

如果链表只包含两个结点时，代码是否能正常工作？

代码逻辑在处理头结点和尾结点的时候，是否能正常工作？

删除链表倒数第n个结点

方法一：一次遍历算法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        if(head==nullptr || n<1)
            return nullptr;
        ListNode *res_head = head;
        ListNode *back = head;
        ListNode *front = head;
        int count = n;
        while(front->next!=NULL && count>0){
            front = front->next;
            --count;
        }
        if(count>1){
            //输入的n大于链表的长度，n无效
            return nullptr;
        }
        
        if(count==1){
            //count==1 则链表的长度等于n
            if(n==1){
                //链表长度为1，移除头结点，返回空指针
                return nullptr;
            }else{
                //链表长度大于1，移除头结点，返回头结点->next
                res_head = res_head->next;
                delete head;
                return res_head;
            }
        }
        
        if(count==0){
            while(front->next != NULL){
                front = front->next;
                back = back->next;
            }
            ListNode *deletenode = back->next;
            back->next = back->next->next;
            delete deletenode;
            return res_head;
        }
 
    }
};

Complexity Analysis

Time complexity : O(L)

The algorithm makes one traversal of the list of L nodes. Therefore time complexity is O(L).

Space complexity : O(1).

We only used constant extra space.

方法二：两次遍历算法

思路

我们注意到这个问题可以容易地简化成另一个问题：删除从列表开头数起的第 (L - n + 1)个结点，其中 L 是列表的长度。只要我们找到列表的长度 LL，这个问题就很容易解决。

算法

首先我们将添加一个哑结点作为辅助，该结点位于列表头部。哑结点用来简化某些极端情况，例如列表中只含有一个结点，或需要删除列表的头部。在第一次遍历中，我们找出列表的长度 LL。然后设置一个指向哑结点的指针，并移动它遍历列表，直至它到达第 (L - n) 个结点那里。我们把第 (L - n) 个结点的 next 指针重新链接至第 (L - n + 2) 个结点，完成这个算法。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode *dummy = new ListNode(0);
        dummy->next = head;
        int length  = 0;
        ListNode first = head;
        while (first != null) {
            length++;
            first = first->next;
        }
        length -= n;
        first = dummy;
        while (length > 0) {
            length--;
            first = first->next;
        }
        first->next = first->next->next;
        return dummy->next;
    }
};

方法三：一次遍历算法

算法

上述算法可以优化为只使用一次遍历。我们可以使用两个指针而不是一个指针。第一个指针从列表的开头向前移动 n+1 步，而第二个指针将从列表的开头出发。现在，这两个指针被 n 个结点分开。我们通过同时移动两个指针向前来保持这个恒定的间隔，直到第一个指针到达最后一个结点。此时第二个指针将指向从最后一个结点数起的第 n个结点。我们重新链接第二个指针所引用的结点的 next 指针指向该结点的下下个结点。

两个有序链表的合并

Example:

Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4

方法一：迭代法

class Solution {
public:
	ListNode * mergeTwoLists(ListNode* l1, ListNode* l2) {
		if (l1 == nullptr && l2 == nullptr) return nullptr;
		if (l1 == nullptr) return l2;
		if (l2 == nullptr) return l1;
		ListNode *head = nullptr,*now = nullptr;
		ListNode *L1 = l1, *L2 = l2;
 
		while (L1 != nullptr || L2 != nullptr) {
			//当L1为nullptr时，L2一定不为nullptr
			if (L1 == nullptr) {
				now->next = L2;
				break;
			}
			//当L2为nullptr时，L1一定不为nullptr
			if (L2 == nullptr) {
				now->next = L1;
				break;
			}
 
			//当L1和L2均不为空时
			if (head == nullptr) {
				if (L1->val < L2->val) {
					head = L1;
					now = head;
					L1 = L1->next;
				}
				else {
					head = L2;
					now = head;
					L2 = L2->next;
				}
			}
			else {
				if (L1->val < L2->val) {
					now->next = L1;
					now = now->next;
					L1 = L1->next;
				}
				else {
					now->next = L2;
					now = now->next;
					L2 = L2->next;
				}
			}
		}
		return head;
	}
};

方法二：递归法

第一次进入if(l1->val < l2->val) 判断的时候的return即为最终返回的头结点。这个函数的目的是返回当前两个参数中val值较小的那个节点指针，并令这个指针指向下一个val值最小的节点。当两个参数中有一个为nul时，直接将另一个参数剩余的所有链表直接连接在要返回的链表后面。

class Solution {
public:
    ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) {
        if(l1 == NULL) return l2;
        if(l2 == NULL) return l1;
        
        if(l1->val < l2->val) {
            l1->next = mergeTwoLists(l1->next, l2);
            return l1;
        } else {
            l2->next = mergeTwoLists(l2->next, l1);
            return l2;
        }
    }
};

This solution is not a tail-recursive, the stack will overflow while the list is too long :)

链表中环的检测

方法一：双指针法

思路

想象一下，两名运动员以不同的速度在环形赛道上跑步会发生什么？

算法

通过使用具有 不同速度 的快、慢两个指针遍历链表，空间复杂度可以被降低至 O(1)O(1)。慢指针每次移动一步，而快指针每次移动两步。

如果列表中不存在环，最终快指针将会最先到达尾部，此时我们可以返回 false。

现在考虑一个环形链表，把慢指针和快指针想象成两个在环形赛道上跑步的运动员（分别称之为慢跑者与快跑者）。而快跑者最终一定会追上慢跑者。这是为什么呢？考虑下面这种情况（记作情况 A） - 假如快跑者只落后慢跑者一步，在下一次迭代中，它们就会分别跑了一步或两步并相遇。

其他情况又会怎样呢？例如，我们没有考虑快跑者在慢跑者之后两步或三步的情况。但其实不难想到，因为在下一次或者下下次迭代后，又会变成上面提到的情况 A。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == nullptr || head->next==nullptr){
            return false;
        }
        ListNode *fast = head->next;
        ListNode *slow = head;
        while(fast!=nullptr && fast->next!=nullptr){
            slow = slow->next;
            fast = fast->next->next;
            if(slow==fast){
                return true;
            }
        }
        return false;
    }
};

方法二：

用 set 存储判断每次存入 next 结点后 set 的 size()有没有发生变化，没有发生变化说明这个结点已经被存储过了，就说明是个环。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        if(head == nullptr || head->next==nullptr){
            return false;
        }
        std::unordered_set<ListNode *> s;
        int cnt = 0;
        while(head!=nullptr){
            s.insert(head);
            if(cnt==s.size()){
                return true;
            }
            cnt = s.size();
            head = head->next;
        }
        return false;
    }
};

反转单链表

方法一：递归法

【数据结构与算法】为什么你学不会递归？告别递归，谈谈我的一些经验

1、定义递归函数功能

假设函数 reverseList(head) 的功能是反转但链表，其中 head 表示链表的头节点。

2. 寻找结束条件

当链表只有一个节点，或者如果是空表的话，你应该知道结果吧？直接啥也不用干，直接把 head 返回呗。代码如下：

3. 寻找等价关系

这个的等价关系不像 n 是个数值那样，比较容易寻找。但是我告诉你，它的等价条件中，一定是范围不断在缩小，对于链表来说，就是链表的节点个数不断在变小，所以，如果你实在找不出，你就先对 reverseList(head.next) 递归走一遍，看看结果是咋样的。例如链表节点如下

我们就缩小范围，先对 2->3->4递归下试试

我们在第一步的时候，就已经定义了 reverseLis t函数的功能可以把一个单链表反转，所以，我们对 2->3->4反转之后的结果应该是这样：

我们把 2->3->4 递归成 4->3->2。不过，1 这个节点我们并没有去碰它，所以 1 的 next 节点仍然是连接这 2。

接下来呢？该怎么办？

其实，接下来就简单了，我们接下来只需要把节点 2 的 next 指向 1，然后把 1 的 next 指向 null,不就行了？，即通过改变 newList 链表之后的结果如下：

也就是说，reverseList(head) 等价于 ** reverseList(head.next)** + 改变一下1，2两个节点的指向。好了，等价关系找出来了，代码如下(有详细的解释)：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==nullptr || head->next==nullptr){
            return head;
        }
        
        ListNode *new_end = head->next;
        ListNode* res = reverseList(head->next);
        new_end->next = head;
        head->next = nullptr;
        return res;
    }
};

方法二：迭代法

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==nullptr || head->next==nullptr){
            return head;
        }
        
        ListNode *cursor = head;
        ListNode *next = head->next;
        head->next = nullptr;
        
        while(next!=nullptr){
            ListNode *temp = next->next;
            next->next = cursor;
            cursor = next;
            next = temp;
        }
        
        return cursor;
    }
};

给定一个带有头结点 `head` 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

方法一：输出到数组

思路和算法

按顺序将每个结点放入数组 A 中。然后中间结点就是 A[A.Length/2]，因为我们可以通过索引检索每个结点。

class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        if(head==nullptr || head->next==nullptr){
            return head;
        }
        vector<ListNode*> A = {head};
        while (A.back()->next != NULL)
            A.push_back(A.back()->next);
        return A[A.size() / 2];
    }
};

方法二：快慢指针法

思路和算法

当用慢指针 slow 遍历列表时，让另一个指针 fast 的速度是它的两倍。当 fast 到达列表的末尾时，slow 必然位于中间。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* middleNode(ListNode* head) {
        if(head==nullptr || head->next==nullptr){
            return head;
        }
        
        ListNode *slow = head, *fast = head;
        while(fast->next!=nullptr){
            slow = slow->next;
            fast=fast->next->next;
            if(fast==nullptr)
                break;
        }
        return slow;
    }
};

南方以北

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
[数据结构与算法] 链表

针对链表的插入、删除操作，需要对插入第一个结点和删除最后一个结点的情况进行特殊处理。这样代码实现起来就会很繁琐，不简洁，而且也容易因为考虑不全而出错。如何来解决这个问题呢？技巧三中提到的哨兵就要登场了。哨兵，解决的是国家之间的边界问题。同理，这里说的哨兵也是解决“边界问题”的，不直接参与业务逻辑。如果我们引入哨兵结点，在任何时候，不管链表是不是空，head 指针都会一直指向这个哨兵结点。我们也...
复制链接

扫一扫