关于第三天的训练,第一第三其实很简单,重点还是再第二道题的构建,看了好几遍视频,看看人家python的解法,好说歹说也磨出来了,不过依然不是很熟悉,还需要再写写,熟悉一下。
203.移除链表元素
给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满足 Node.val == val 的节点,并返回 新的头节点 。
示例 1:
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
示例 2:
输入:head = [], val = 1
输出:[]
示例 3:
输入:head = [7,7,7,7], val = 7
输出:[]
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def removeElements(self, head:ListNode, val: int) -> ListNode:
dummy_head = ListNode(next=head)
cur = dummy_head
while cur.next != None:
if cur.next.val == val:
cur.next = cur.next.next
else:
cur = cur.next
return dummy.next
if __name__ == '__main__':
a = ListNode(1)
b = ListNode(2)
c = ListNode(3)
d = ListNode(4)
e = ListNode(3)
a.next = b
b.next = c
c.next = d
d.next = e
ss = Solution()
rr = ss.removeElements(a,3)
while rr.next != None:
print(rr.next.val)
rr.next = rr.next.next
/**
* 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* removeElements(ListNode* head, int val) {
ListNode* dummy = new ListNode(0);
dummy->next = head;
ListNode* cur = dummy;
while(cur->next){
if(cur->next->val == val){
cur->next = cur->next->next;
}
else{
cur = cur->next;
}
}
return dummy->next;
}
};
707.设计链表
这道题很繁琐,我就先只写单链表的写法了,双链表之后再说
# 设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性:val 和 next。val 是当前节点的值,next 是指向下一个节点的指针/引用。如果要使用双向链表,则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
# 在链表类中实现这些功能:
# get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1。
# addAtHead(val):在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表的第一个节点。
# addAtTail(val):将值为 val 的节点追加到链表的最后一个元素。
# addAtIndex(index,val):在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度,则该节点将附加到链表的末尾。如果 index 大于链表长度,则不会插入节点。如果index小于0,则在头部插入节点。
# deleteAtIndex(index):如果索引 index 有效,则删除链表中的第 index 个节点。
# MyLinkedList linkedList = new MyLinkedList();
# linkedList.addAtHead(1);
# linkedList.addAtTail(3);
# linkedList.addAtIndex(1,2); //链表变为1-> 2-> 3
# linkedList.get(1); //返回2
# linkedList.deleteAtIndex(1); //现在链表是1-> 3
# linkedList.get(1); //返回3
class Node:
def __init__(self, val):
self.val = val
self.next = None
class MyLinkedList:
def __init__(self):
self._head = Node(0)
self._count = 0
def get(self, index: int) -> int:
"""
Get the value of the index-th node in the linked list. If the index is invalid, return -1.
"""
if index < 0 or index >= self._count: # 这里是>=,要注意
return -1
else:
node = self._head
for i in range(index+1):
node = node.next
return node.val
def addAtHead(self, val: int) -> None:
self.addAtIndex(0,val)
def addAtTail(self, val: int) -> None:
self.addAtIndex(self._count,val)
def addAtIndex(self, index: int, val: int) -> None:
if index < 0:
index = 0
if index > self._count:
return
cur = self._head
newnode = Node(val)
for i in range(index):
cur = cur.next
tmp = cur.next
newnode.next = tmp
cur.next = newnode
self._count += 1
def deleteAtIndex(self, index: int) -> None:
if index < 0:
index = 0
if index >= self._count: # 这里是>=,要注意
return
cur = self._head
for i in range(index):
cur = cur.next
if cur.next != None:
cur.next = cur.next.next
else:
cur.next = None
self._count -= 1
if __name__ == '__main__':
# obj = MyLinkedList()
# # param_1 = obj.get(0)
# obj.addAtHead(1)
# obj.addAtTail(3)
# obj.addAtIndex(1,2)
# param_1 = obj.get(1)
# print(param_1)
# obj.deleteAtIndex(1)
# obj.deleteAtIndex(1)
obj = MyLinkedList()
obj.addAtHead(2)
obj.deleteAtIndex(1)
obj.addAtHead(2)
obj.addAtHead(7)
obj.addAtHead(3)
obj.addAtHead(2)
obj.addAtHead(5)
obj.addAtTail(5)
param_1 = obj.get(5)
print(param_1)
obj.deleteAtIndex(6)
obj.deleteAtIndex(4)
# 听了卡哥的视频,然后一点点磨出来了,还有点迷迷糊糊,感觉还有必要再写一次
206.反转链表
这个不是很难,不过递归的概念我还不是很熟悉,所以先熟悉双指针吧,其实之前我用自己的方法做出来了,虽然很烂,哈哈
# 给你单链表的头节点 head ,请你反转链表,并返回反转后的链表。
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
class Solution:
def reverseList(self, head: [ListNode]) -> [ListNode]:
temp_list = []
while head != None:
temp_list.append(head.val)
head = head.next
#temp_list.append(head.val)
while head.next != None:
temp_list.append(head.val)
head = head.next
temp_list.append(head.val)
length = len(temp_list)
cc = [chr(97+i) for i in range(length)]
dummy = ListNode(0)
cur = dummy
for i in range(length):
cc[i] = ListNode(temp_list[length-i-1])
cur.next = cc[i]
cur = cur.next
return dummy.next
#更新卡哥的双指针方法,有点懂了
class SolutionB:
def reverseList(self, head: [ListNode]) -> [ListNode]:
pre = None
cur = head
while cur != None:
tmp = cur.next # 1.保存下一个节点
cur.next = pre # 2.转方向
pre = cur # 3.pre右移
cur = tmp # 4. cur右移
return pre
# 递归是抄的,还不是很明白
class SolutionC:
def reverseList(self, head: [ListNode]) -> [ListNode]:
def rever(pre,cur):
if cur == None:
return pre
tmp = cur.next
cur.next = pre
return rever(cur,tmp)
return rever(None,head)
if __name__ == '__main__':
a = ListNode(1)
b = ListNode(2)
c = ListNode(3)
d = ListNode(4)
e = ListNode(5)
a.next = b
b.next = c
c.next = d
d.next = e
ss = Solution()
rr = ss.reverseList(a)
while a.next != None:
print(a.val)
a= a.next
while rr.next != None:
print(rr.val)
rr = rr.next
print(rr.val)
# 虽然可能是有缺陷的解答,并不是最优解,但是这道题是我在没有看答案的情况下, 独自写出来的
# 有没有有一种可能,我理解了一点点,作为链表的含义,我知道了怎样去操作链表 ---2022-01-18