算法题day4

一、链表相关知识概括：

1.链表定义：链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域，一个是指针域。根据指针可分为单链表和双链表。

2.存储方式：注意链表在内存中可不是连续分布的，它是靠指针连接并且散乱分布的。

3.性能分析：

	插入/删除	查询	适用场景
数组	O(N)	O(1)	数据量固定、频繁查询、较少增删
链表	O(1)	O(N)	数据量不固定，频繁增删，较少查询

4.在一般的链表操作中，设置一个虚拟的头节点再进行操作，比较方便理解。

二、题目练习:

1. leetcode题目203 移除链表元素（easy）：

题目描述：

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

思路：创建虚拟头节点，再遍历整个链表，遍历的时候如果Node.val == val,则cur.next  = cur.next.next

解决：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        dummy_head = ListNode(next=head)
        cur = dummy_head
        while cur.next:
            if cur.next.val == val:
                cur.next = cur.next.next
            else:
                cur = cur.next
        return dummy_head.next

2.leetcoe 题目 反转链表（easy）：

题目描述：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思路：创建虚拟头节点，遍历过程中，反转指针

解决：

# Definition for singly-linked list.

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        cur = head
        pre = None
        while cur:
            next_ = cur.next
            cur.next = pre
            pre = cur
            cur = next_
        return pre

3.leetcode 题目707设计链表（medium）：

题目描述太长：放链接:leetcode题目707

思路：每一个功能都画图，再遍历 并需要正确判断遍历什么时候停下来，再做相应的链表操作。

解决：

class ListNode:
    def __init__(self,val = 0,next = None):
        self.val = val
        self.next = next
class MyLinkedList:
    def __init__(self,val = 0,next =None):
        self.bef_node = ListNode()
        self.size = 0

    def get(self, index: int) -> int:
        if index<0 or index>=self.size:
            return -1
        cur = self.bef_node.next
        for i in range(index):
            cur = cur.next
        return cur.val
    def addAtHead(self, val: int) -> None:
        new_node = ListNode(val =val)
        pre = self.bef_node.next
        self.bef_node.next = new_node
        new_node.next = pre
        self.size +=1
    def addAtTail(self, val: int) -> None:
        cur = self.bef_node
        while cur.next:
            cur = cur.next
        cur.next= ListNode(val =val)
        self.size +=1
    def addAtIndex(self, index: int, val: int) -> None:
        if index < 0 or index > self.size:
            return
        cur = self.bef_node
        new_node = ListNode(val =val)
        while index>0:
            cur = cur.next
            index -= 1
        pre = cur.next
        cur.next = new_node
        new_node.next = pre
        self.size += 1

    def deleteAtIndex(self, index: int) -> None:
        if index < 0 or index >= self.size:
            return
        cur = self.bef_node
        while index>0:
            cur = cur.next
            index -= 1
        pre = cur.next
        cur.next = pre.next
        self.size -= 1


# 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)

4.leetcode题目160 相交链表（easy）：

题目描述：

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。

思路：遍历链表A，将每一个节点放入集合中，在遍历B的过程中判断B的节点是否存在集合中，如果存在，则返回当前节点。

解决：

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

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> Optional[ListNode]:
        res =set()
        cur = headA
        while cur:
            res.add(cur)
            cur = cur.next
        cur = headB
        while cur:
            if cur in res:
                return cur
            cur = cur.next
        return None

5.leetcode题目237 删除链表中的节点（medium）：

题目链接：leetcode237删除链表中的节点

思路:直接将该节点整容，val值变为下一节点的val,指针也指向下下节点.

解决：

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

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val = node.next.val
        node.next = node.next.next

三、复习二分查找方法：

1.leetcode题目74 搜索二维矩阵（medium）：

我的思路：先找到target所在行，再行内二分

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        m = len(matrix)
        n = len(matrix[0])
        i = 0
        while i < m and target>matrix[i][n-1]:
            i +=1
        left = 0
        right = n-1
        if i == m:
            return False
        while left<=right:
            middle = left + int((right-left)/2)
            if matrix[i][middle] < target:
                left = middle + 1
            elif matrix[i][middle] > target:
                right = middle - 1
            else:
                return True
        return False

（此题：可以先转换成一维索引，再二分）