代码随想录算法训练营第三天 | 203.移除链表元素、707.设计链表、206.反转链表

203.移除链表元素

文章链接：203.移除链表元素
视频链接：手把手带你学会操作链表 | LeetCode：203.移除链表元素

题目描述
203.移除链表元素

题解

解法一：移除头节点/非头节点

以不同方式移除头节点及非头节点。

class Solution {
public:
	ListNode* removeElements(ListNode* head, int val) {
		/*
			（一）
			删除头节点。
			使头指针指向所指节点的下一个节点。
		*/
		while (head != nullptr && head->val == val) {
			// 如前n个节点均等于val，则移除头节点后下一个节点仍为头节点，
			//  因此应使用while循环
			ListNode* tmp = head; // tmp指向目标节点，随后释放该节点
			head = head->next;
			delete tmp;
		}

		/*
			（二）
			删除非头节点。
			查找该节点的上一个节点，使其指向该节点的下一个节点，
			并手动释放该节点。
		*/
		ListNode* cur = head;
		// 删除任一节点需获取该节点的上一个节点，因此令cur指向头节点
		while (cur != nullptr && cur->next != nullptr) {
			if (cur->next->val == val) {
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				delete tmp;
			}
			else {
				cur = cur->next;
				// 指针左移一位，并判断下一个节点是否为目标节点
			}
		}

		// 返回头节点
		return head;
	}
};

时间复杂度：O(n)
空间复杂度：O(1)

解法二：虚拟头节点

通过解法一移除节点需判断目标节点是否为头节点。
解法二能以一种统一的方式删除节点。

class Solution {
public:
	ListNode* removeElements(ListNode* head, int val) {
		ListNode* dummyHead = new ListNode(0);
		dummyHead->next = head;

		ListNode* cur = dummyHead;
		while (cur->next != nullptr) {
			if (cur->next->val == val) {
				ListNode* tmp = cur->next;
				cur->next = cur->next->next;
				delete tmp;
			}
			else {
				cur = cur->next;
			}
		}
		
		// 原头节点可能已被移除，需重新定位head，再将其返回
		head = dummyHead->next;
		delete dummyHead;
		return head;
	}
};

707.设计链表

文章链接：707.设计链表
视频链接：帮你把链表操作学个通透！LeetCode：707.设计链表

题目描述
707.设计链表

题解
本题要点如下：

1. 定义LinkedNode结构，内含数据域、指针域及其该结构的构造函数。定义私有成员size、dummyHead，并于该类构造成员对前者进行初始化。
2. 设置虚拟头节点dummyHead使得能以一种统一的方式对节点执行相关操作（无需区分头节点及非头节点）。
3. 画图模拟链表操作再敲代码可提高解题效率。
4. 需要查找index为n的节点均需定义cur指针进行遍历。
   获取index == n的目标节点则令cur指向dummyHead->next，获取目标节点的上一个节点（插入或删除节点均需要获取目标节点的上一个节点）则令cur指向dummyHead。
   左移cur指针代码如下，以下代码仅适用于所有节点下标从 0 开始，可代入index == 0验证边界条件是否合法:

while(n) {
cur = cur->next;
n--;
}

5. 查找index == n的节点并执行相关操作步骤如下：
   ① 按题目要求判断index是否合法。
   ② 定义cur指针，并将其移至指定位置。
   ③ 对目标节点执行相关操作。（删除节点需手动释放内存）
   ④ 手动更改m_size。

源代码

class MyLinkedList {
public:
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    MyLinkedList() {
        _dummyHead = new LinkedNode(0); 
        _size = 0;
    }

    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        return cur->val;
    }

    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }

    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(cur->next != nullptr){
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }

    void addAtIndex(int index, int val) {

        if(index > _size) return;
        if(index < 0) index = 0;        
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }

    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        tmp=nullptr;
        _size--;
    }

    void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

206.反转链表

文章链接：206.反转链表
视频链接：帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法

题目描述
206.反转链表

题解

解法一：双指针法

1. 定义cur指针指向当前节点，定义pre指针指向当前节点的上一个节点。
2. 由于翻转后原头节点为尾节点，尾节点指向nullptr，故令cur初始化为head，pre初始化为nullptr。
3. 翻转链表后pre指向链表头节点，cur指向nullptr且无需指向头节点，故while循环边界条件为cur != nullptr。
4. 执行翻转操作前，需定义tmp指针储存cur->next，否则将丢失该节点。
5. cur->next = pre即执行翻转操作。
6. 由于pre将指向cur，若先令cur = tmp将导致pre和cur指向同一节点。因此必须先令pre = cur，后令cur = tmp。
   源代码

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr; 
        ListNode* cur = head;

        while(cur) {
            ListNode* tmp = cur->next;
            cur->next = pre; // 执行翻转操作
            pre = cur;
            cur = tmp; 
        }

        return pre;
    }
};

时间复杂度: O(n)
空间复杂度: O(1)

解法二：递归法

代码逻辑同解法一，即不断令cur指向pre，解法二将其写为递归形式。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    	// 将pre、cur分别初始化为nullptr、head
        return reverse(nullptr, head);
    }
    
    ListNode* reverse(ListNode* pre, ListNode* cur)
    {
        if(cur == nullptr) return pre;
        ListNode* tmp = cur->next;
        cur->next = pre;
        // 即pre = cur, cur = tmp。
        return reverse(cur, tmp);
    }
};

时间复杂度: O(n)
空间复杂度: O(n)
需递归处理链表各个节点且调用了n层栈空间。

解法三：反向递归法

参考206.反向递归法“从后往前递归”，即不断将头节点外链表的尾节点指向头节点，实现翻转操作。

后记
通过这三道题夯实了链表的基础呢。Carl哥选题好用心。:’
找准方向循序渐进。
慢慢的也能学会！