leetcode 打卡 day3 203.移除链表元素 707.设计链表 206.反转链表

---

提示：以下是本篇文章正文内容，下面案例可供参考
定义链表：
Python

class ListNode:
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

C++
通过自己定义构造函数初始化节点：

ListNode* head = new ListNode(5);

使用默认构造函数初始化节点：

ListNode* head = new ListNode();
head->val = 5;

一、203.移除链表元素

1.题目链接：

link

2.独立做题问题总结

3.解法总结：

1. 直接移除：因为第一个节点前没有节点，所以对于第一个节点，我们直接跳到下一个节点，因此实现需要首先对第一个节点进行判断，然后对接下来的节点进行循环判断

		while (head and head.val == val):
            head = head.next     
        res = head
        while(res != None and res.next!= None):
            # cur = head.val
            if res.next.val == val:
                res.next = res.next.next
                # print(f"SAME{head}")
            else:
                res = res.next
                # print(head)
        return head  
		

2. 设置虚拟头节点：通过设置虚拟头节点，将整个链表放在同一个循环里进行判断

		dummyhead = ListNode(next=head)
        cur = dummyhead
        while(cur.next!= None):
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummyhead.next
		

3. 递归

 		if not head:
            return head
        head.next = self.removeElements(head.next, val)
        return head if head.val != val else head.next

4. Details：
   循环条件：head.next ！= None
   返回：dummyhead.next
   需要定义一个临时指针指向头节点，对临时指针进行操作，最后返回头节点。

二、leetcode 707.设计链表

1.题目链接：

link
get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。

addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。

addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。

addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。

deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

2.独立做题问题总结

3.解法总结：

创建Node类，定义节点，包含节点的值和下一位指针

class Node:
	    def __init__(self,val):
	        self.val = val
	        self.next = None

创建LinkedList类，定义函数， linkedlist可以记录头节点和长度。

class MyLinkedList:
	// 定义虚拟头节点
    def __init__(self):
        self.head = Node(0)
        self.count = 0
	// 当index在list范围内时，进行查找。
	// 访问index位，用index + 1 为终止条件
    def get(self, index: int) -> int:
        if 0 <= index < self.count:
            node = self.head
            for i in range(index + 1):
                node = node.next
            return node.val
        return -1

    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0,val)
	//判断尾节点条件： h.next != None
    def addAtTail(self, val: int) -> None:
        # newnode = Node(val)
        # h = self.head
        # while(h.next != None):
        #     h = h.next
        # h.next = newnode
        # self.count += 1
        self.addAtIndex(self.count,val)
	// 索引指到index前一位，即终止位为index，记录当前节点下一位节点，将当前节点指向新节点，新节点指向下一位节点。
	// 创建新节点： newnode = Node(val) （== ListNode（val））
    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0:
            index = 0
        elif index > self.count:
            return
        self.count += 1
        newnode = Node(val)
        temp = self.head
        for i in range(index):
            temp = temp.next
        cur = temp.next
        temp.next = newnode
        newnode.next = cur
       

    def deleteAtIndex(self, index: int) -> None:
        if 0 <= index < self.count:
            temp = self.head
            self.count -= 1
            for i in range(index):
                temp = temp.next
            temp.next = temp.next.next
            	

---

三、leetcode 206.反转链表

1.题目链接：

link

2.独立做题问题总结

双指针

3.解法总结：

1. 双指针法
   pre指针初始化为None，指向头指针前一位
   cur指针指向头指针，cur指针指向空时停止循环
   先移动pre指针
   将cur.next先储存temp，cur.next指向pre，更新pre.next为cur，cur = temp
   时间复杂度：O(n^2)
   空间复杂度：O(1)

		pre = None
        cur = head
        while(cur != None):
            temp = cur.next
            cur.next = pre
            pre = cur
            cur = temp
        return pre	
		

2. 递归法

        def reverse(pre,cur):
            if not cur:
                return pre
             
            tmp = cur.next
            cur.next = pre

            return reverse(cur,tmp)
        
        return reverse(None,head)