leetcode题目摘录

Author: imoyao

Linked_list/leetcode_206.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@create: 2022/3/25 17:59
+@file: leetcode_234.py
+@author: imoyao
+@email: immoyao@gmail.com
+@desc:
+"""
+'''
+给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
+
+
+示例 1：
+
+
+输入：head = [1,2,3,4,5]
+输出：[5,4,3,2,1]
+示例 2：
+
+
+输入：head = [1,2]
+输出：[2,1]
+示例 3：
+
+输入：head = []
+输出：[]
+
+
+提示：
+
+链表中节点的数目范围是 [0, 5000]
+-5000 <= Node.val <= 5000
+
+
+进阶：链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/reverse-linked-list
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+'''

Linked_list/leetcode_234.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@create: 2022/3/25 17:59
+@file: leetcode_234.py
+@author: imoyao
+@email: immoyao@gmail.com
+@desc:
+"""
+'''
+给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
+
+
+
+示例 1：
+
+
+输入：head = [1,2,2,1]
+输出：true
+示例 2：
+
+
+输入：head = [1,2]
+输出：false
+
+
+提示：
+
+链表中节点数目在范围[1, 105] 内
+0 <= Node.val <= 9
+
+
+进阶：你能否用O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/palindrome-linked-list
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+'''

Linked_list/leetcode_61.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@create: 2022/3/25 17:59
+@file: leetcode_234.py
+@author: imoyao
+@email: immoyao@gmail.com
+@desc:
+"""
+'''
+给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动k个位置。
+
+
+
+示例 1：
+
+
+输入：head = [1,2,3,4,5], k = 2
+输出：[4,5,1,2,3]
+示例 2：
+
+
+输入：head = [0,1,2], k = 4
+输出：[2,0,1]
+
+
+提示：
+
+链表中节点的数目在范围 [0, 500] 内
+-100 <= Node.val <= 100
+0 <= k <= 2 * 109
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/rotate-list
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+'''

Linked_list/leetcode_707.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@create: 2022/3/25 17:55
+@file: leetcode707.py
+@author: imoyao
+@email: immoyao@gmail.com
+@desc:
+"""
+'''
+设计链表的实现。您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：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 个节点。
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/design-linked-list
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+'''
+
+
+class Node:
+
+    def __init__(self, val, next_node=None):
+        self.val = val
+        self.next = next_node
+
+    # def __repr__(self):
+    #     return self.val
+
+
+class NodeList:
+
+    def __init__(self):
+        self.size = 0
+        self.head = Node(0)
+
+    def __iter__(self):
+        current = self.head
+        while current.next is not None:
+            yield current.val
+            current = current.next
+
+    def get(self, index):
+        if index < 0 or index >= self.size:
+            return -1
+        current = self.head
+        for _ in range(index + 1):
+            current = current.next
+        return current.val
+
+    def add_at_index(self, index, val):
+        if index > self.size:
+            return None
+        if index < 0:
+            index = 0
+
+        self.size += 1
+        # 找到被放置节点的前一个，在哪里放置，就for几次
+        prev = self.head  # 基准节点
+        for _ in range(index):
+            prev = prev.next
+        # 构造被插入节点
+        add_node = Node(val)
+        add_node.next = prev.next
+        # 放入断链位置
+        prev.next = add_node
+
+    def add_at_head(self, val):
+        self.add_at_index(0, val)
+
+    def add_at_tail(self, val):
+        self.add_at_index(self.size, val)
+
+    def delete_at_index(self, index):
+        if index < 0 or index > self.size:
+            return None
+        self.size -= 1
+        prev = self.head
+        for _ in range(index):
+            prev = prev.next
+        prev.next = prev.next.next
+if __name__ == '__main__':
+
+
+    nl = NodeList()
+    for item in range(10):
+        if item % 2 == 0:
+            nl.add_at_head(item)
+        else:
+            nl.add_at_tail(item)
+
+    for item in nl:
+        print(item)

Linked_list/leetcode_92.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+@create: 2022/3/25 17:59
+@file: leetcode_234.py
+@author: imoyao
+@email: immoyao@gmail.com
+@desc:
+"""
+'''
+给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。
+ 
+
+示例 1：
+
+
+输入：head = [1,2,3,4,5], left = 2, right = 4
+输出：[1,4,3,2,5]
+示例 2：
+
+输入：head = [5], left = 1, right = 1
+输出：[5]
+ 
+
+提示：
+
+链表中节点数目为 n
+1 <= n <= 500
+-500 <= Node.val <= 500
+1 <= left <= right <= n
+ 
+
+进阶： 你可以使用一趟扫描完成反转吗？
+
+通过次数270,253提交次数489,409
+
+来源：力扣（LeetCode）
+链接：https://leetcode-cn.com/problems/reverse-linked-list-ii
+著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
+'''

Linked_list/readme.md

@@ -11,7 +11,7 @@
 只要有足够的内存，就可以为链表分配内存。
 
 ## 缺点
-假如你**只**想读取最后一个元素，不能直接读取。但是你不知道它所在的地址，必须从头开始访问，直到访问到最后一个元素。同时访问所有元素时，效率很高，单独访问时，因为需要跳跃，导致效率很低。
+假如你**只**想读取最后一个元素，不能直接读取。由于你不知道它所在的地址，必须从头开始访问，直到访问到最后一个元素。同时访问所有元素时，效率很高，单独访问时，因为需要跳跃，导致效率很低。
 
 ## 复杂度比较
 

Tree/readme.md

@@ -21,7 +21,8 @@
 ## 术语
 - **节点的度**：一个节点含有的子树的个数称为该节点的度；
 - **树的度**：一棵树中，最大的节点度称为树的度；
--  **叶节点**或终端节点：度为零的节点；
+- **叶节点**或终端节点：度为零的节点；
+
     ![节点与度](img/21AKcEALa8.png)
 - 非终端节点或分支节点：度不为零的节点；
 - 父亲节点或**父节点**：若一个节点含有子节点，则这个节点称为其子节点的父节点；

raw/datastructre/linkedlist/linkedlist.py

@@ -111,11 +111,11 @@ def combine(l1, l2):
 
 # leetcode 876 链表的中间结点 python实现
 class Solution:
-    def middleNode(self, head):
+    def middle_node(self, head):
         # 首先要知道链表一共有多少个结点
         count = 0
         res = {}
-        while head != None:
+        while head is not None:
             count += 1
             res[count] = head
             head = head.next