力扣刷题day3- 203.移除链表元素 - 707.设计链表 - 206.反转链表

203.移除链表元素

题目： 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。力扣

思路： 注意： 借用虚拟头节点的做法，不断往后

#!/usr/bin/env python
# -*- coding: utf-8 -*-
class ListNode(object):
	def __init__(self,val=0,next=None):
		self.val =val
		self.next=next
class Solution(object):
	def removeElements(self,head,val):
	# ## 看上去贼简单的题，写起来一堆的bug ! 思路要全面清晰！
	### 思路1 ： 双指针一前一后
    # ## 题目 https://leetcode.cn/problems/remove-linked-list-elements/submissions/
	# # 双指针思想，一前一后，先删除后面等于val的值。当以dummy空时，除了考虑特殊情况，还要注意最后一个节点是否需要单独判断
	# 	dummy=ListNode(-1)
	# 	dummy.next=head
	# 	# 先考虑特殊情况，头节点的分析
	# 	# 头结点 为[]的情况
	# 	if not head:
	# 		return head
	# 	# 头结点为单值
	# 	if head.next==None and head.val !=val:
	# 		return head
	# 	former=dummy
	# 	while head:
	# 		if head.val !=val:
	# 			former.next=head
	# 			former=former.next
	# 			head=head.next
	# 		else:
	# 			head=head.next
	# 	### 上面如果当最后一个head也为val时，当前的head到了空而退出，虽然前面的former一直指向的是非val的值但是former.next在为赋值时是保留的上一个head中的next（ if中，former.next=head, former=former.next，这段代码里最后former.next值并未新给)， 当最后一个head为val时走的else，else中的代码只会让head往前走，当由head.next得到的新的head为空而退出时，而上一个former.的next由于没单独给值可能沿用了head的next指向为val 的元素，导致这个next指向为val的元素而无法正确判断。所以需要单独判断下最后时former.next值。 如[1,2,3],3 这个最后的3就没法删除。因此要加判断最后一个节点(即former.next)是否为val
	# 	if former.next !=None and former.next.val ==val: # 注意 只有当 former.next!=None时，才能写 former.next.next,否则会报错 。如[1,2,3] ,val=3
	# 		former.next=None
	# 	else:
	# 		pass
	# 	return dummy.next
		
		#### 思路2 ：只用虚拟头结点
		dummy=ListNode(-1)
		dummy.next=head 
		cur=dummy # 此处cur为dummy而非dummy.next
		while cur.next!=None: # 这相当于从dummy.next 第一个节点开始判断
			if cur.next.val ==val:
				cur.next=cur.next.next  # 删除cur.next节点
			else:
				cur=cur.next 
		return dummy.next 
			
		

707.设计链表

题目描述主要内容： 

设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。

完整题目见链接 ： 力扣

实现： 

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

class MyLinkedList(object):

    def __init__(self):
        self._head  = Node(-1) # 虚拟头结点 
        self._count = 0  # 添加的节点数

    def get(self, index):
        """
        :type index: int
        :rtype: int
        """
        if 0 <= index <self._count:
            node = self._head 
            for _ in range(index+1):
                node = node.next 
            return node.val 
        else:
            return -1 
    


    def addAtHead(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(0,val) 

    def addAtTail(self, val):
        """
        :type val: int
        :rtype: None
        """
        self.addAtIndex(self._count,val)


    def addAtIndex(self, index, val):
        """
        :type index: int
        :type val: int
        :rtype: None
        """
        if index < 0 :
            index = 0 
        elif index > self._count:
            return 
        
        # 计数累加
        self._count +=1

        add_node = Node(val)
        prev_node, current_node = None, self._head
        for _ in range(index+1):
            prev_node,current_node = current_node,current_node.next 

        prev_node.next,add_node.next = add_node,current_node


    def deleteAtIndex(self, index):
        """
        :type index: int
        :rtype: None
        """
        if 0<=index<self._count:
            # 计数 -1 
            self._count -=1
            prev_node,current_node = None,self._head
            for _ in range(index+1):
                prev_node,current_node = current_node,current_node.next 
            prev_node.next, current_node.next =current_node.next, None 



# Your MyLinkedList object will be instantiated and called as such:
# obj = MyLinkedList()
# param_1 = obj.get(index)
# obj.addAtHead(val)
# obj.addAtTail(val)
# obj.addAtIndex(index,val)
# obj.deleteAtIndex(index)

206.反转链表

题目描述 ：

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 

力扣

主要思路： 利用头插法

# 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
        """
        # #  # 头插法： 主要是为保持一对前后指向，cur 指向候选的节点，pre指向反转后的开始节点，不断平行往前走。注意：初试值cur为头结点，pre初始值为None。 这里不适合用一前一后的虚拟头结点来做。 
        cur,pre=head ,None 
        while cur:
            temp=cur.next 
            cur.next=pre
            pre=cur 
            cur=temp 

        return pre 

        # ## 参考labuladong 的递归反转：，加深下对递归的理解应用
        # def reverse(pre,cur):
        #     # 出口
        #     if not cur:
        #         return pre
            
        #     # 反转
        #     tmp=cur.next
        #     cur.next=pre
        #     # 对后面的节点同样进行递归操作
        #     return reverse(cur,tmp)
        # return reverse(None,head)


        ### 之前自己的写法，这个也通过了。但是有点繁琐。 
      # if head==None or head.next==None:  # 考虑为空或者只有一个节点的情况
        #     return head 
        # former =head.next 
        # later=head
        # later.next=None 
        # while former !=None:
        #     temp=former.next
        #     former.next=later
        #     later=former
        #     former=temp
        # return later