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

203 移除链表元素

203 移除链表元素-题目链接

解题思路

主要遇到的问题就是那两个测试用例

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

head = [6, 6, 6, 6, 6, 6, 6]
val = 6


class Solution(object):
    def removeElements(self, head, val):
        """
        :type head: ListNode
        :type val: int
        :rtype: ListNode
        """
        nodes=ListNode()
        nodes.next=head
        p1=nodes
        p2=nodes
        while(p1.next!=None and p2!=None):
            p1=p1.next
            if(p1.val==val and p1.next!=None):
                while(p1.next!=None):
                    if(p1.next.val==val):
                        p1=p1.next
                    else:
                        break
                p2.next=p1.next
                p2=p2.next
                if(p1.next!=None):
                    p1=p1.next
            else:
                if(p1.next!=None):
                    p2=p1
        if (p1.val==val and p2!=None):
            p2.next=p1.next
        return nodes.next


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


if __name__ == "__main__":
    # node1 = ListNode(6)
    # node2 = ListNode(2)
    # node3 = ListNode(6)
    # node4 = ListNode(3)
    # node5 = ListNode(4)
    # node6 = ListNode(5)
    # node7 = ListNode(6)

    node1 = ListNode(6)
    node2 = ListNode(6)
    node3 = ListNode(6)
    node4 = ListNode(6)
    node1.next = node2
    node2.next=node3
    node3.next=node4
    # node4.next=node5
    # node5.next=node6
    # node6.next=node7
    solu=Solution()
    solu.removeElements(node1,val)

代码随想录-203.移除链表元素

707 设计链表

707 设计链表-题目链接

解题思路

对于这道题，我只能说真的对我来说恶心到我了，我以为首先它创建一个 MyLinkedList()就会直接有我的next，按道理来说没问题啊，我真的是呜呜呜呜，可是我真的是失策了，它的调用函数是这样的

    obj = MyLinkedList()
    obj.addAtHead(1)
    obj.addAtTail(3)
    obj.addAtIndex(1,2)
    param_1 = obj.get(1)
    obj.deleteAtIndex(1)
    param_1 = obj.get(1)

这就代表了它紧紧只是知道self一个节点，那么那个节点应该是头节点，应该当成头节点来处理，看示例也是这样的，只能说还是我不会看啊

输入
["MyLinkedList", "addAtHead", "addAtTail", "addAtIndex", "get", "deleteAtIndex", "get"]
[[], [1], [3], [1, 2], [1], [1], [1]]
输出
[null, null, null, null, 2, null, 3]

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/design-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

最后

class MyLinkedList(object):

    def __init__(self,val=0):
        self.val=val
        self.next=None
        self.size=-1

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if(self.size<0 or index>self.size):
            return -1
        p=MyLinkedList()
        p=self.next
        while(p.next!=None):
            if(index==0):
                return p.val
            else:
                index-=1
                p=p.next
        if(p.next==None and index==0):
            return p.val


    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        add=MyLinkedList(val)
        add.next=self.next
        self.next=add
        self.size+=1


    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        p=MyLinkedList()
        p=self
        while(p.next!=None):
            p=p.next

        add=MyLinkedList(val)
        p.next=add
        self.size+=1


    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if(self.size+1<index):
            return
        if(index==0):
            self.addAtHead(val)
        elif(index==self.size+1):
            self.addAtTail(val)
        else:
            add = MyLinkedList(val)
            p = MyLinkedList()
            p = self.next
            while(p.next!=None):
                # 不是最后一个在index这个地方插入
                if(index==1):
                    add.next=p.next
                    p.next=add
                    self.size += 1
                    return
                else:
                    index-=1
                    p=p.next



    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        p = MyLinkedList()
        p = self
        if(self.size<0 or self.size<index):
            return
        while(p.next!=None):
            if(index==0):
                p.next=p.next.next
                self.size -= 1
                return
            else:
                p=p.next
                index-=1

206 反转链表

解题思路

暴力求解，新搞2个节点

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if(head!=None):
            pre=ListNode()
            p=head
            pre.val=p.val
            pre.next=None
            # self是头节点
            while(p.next!=None):
                p=p.next
                cur = ListNode()
                cur.val=p.val
                cur.next=pre
                pre=cur
    
            return pre
        else:
            return head

不需要新增节点，在原节点上修改即可，这一次结果就非常的优美了

# Definition for singly-linked list.
class ListNode(object):
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next
# 输入：head = [1,2]
# 输出：[2,1]
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head!=None:
            cur=head
            pre=None
            while(cur!=None):
                temp=cur.next
                cur.next=pre
                pre=cur
                cur=temp
            return pre

        else:
            return head


if __name__=="__main__":
    node1=ListNode(1)
    node2=ListNode(2)
    node1.next=node2
    solu=Solution()
    solu.reverseList(node1)

最后附上三题的视频讲解