2024.8.20 Python，链表，二叉树

1.二叉树的一些理解

下面是我对二叉树的一些进一步的理解，我不知道对不对，但是目前而言说的通。

class TreeNode:
	def __init__(self,val=0,left=None,right=None)：
		self.val=val
		self.right=right
		self.left=left

class Solution:
	def maxDepth(self,root:TreeNode)->int:
		if not root:
			return 0
		left_depth=self.maxDepth(root.left)
		right_depth=self.maxDepth(root.right)
		return max(left_depth,right_depth)+1

这个代码其实先做初始化，定义什么是TreeNode，__init__是属性，我能理解他在干嘛， 但是我想不明白我什么时候会去用这个东西。
现在假设只有两层，尝试捋这个逻辑：
maxDepth的括号里，给root定义为二叉树的数据类型，在下面的root.left里对root进行left，就找上面的定义，也就是这个节点的left带入，第二层函数里的self.maxDepth()为空，第三层就return 0了，第二层有一个return +1，第一层有个return+1，最后为2
val是值，简单的二叉树数据调用如下：

class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val      # 存储节点的值
        self.left = left    # 指向左子节点
        self.right = right  # 指向右子节点

# 创建一个二叉树的节点
root = TreeNode(10)
root.left = TreeNode(5)
root.right = TreeNode(15)

# 访问根节点的值
print(root.val)         # 输出: 10
print(root.left.val)    # 输出: 5
print(root.right.val)   # 输出: 15

2.链表

突然发现，学二叉树得先学链表，那我不如直接看链表
链表是线性表，是一维的，保存了现在这个数的值和下一个数的地址，分为表元素域，下一结点链接域，
第一个叫头结点，最后一个叫尾节点
题目：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：
输入：l1 = [], l2 = []
输出：[]
示例 3：
输入：l1 = [], l2 = [0]
输出：[0]

方法一：递归：

class ListNode:
	def __init__(self,val=0,next=None):
		self.val=val
		self.next=next
class Solution:
	def mergeTwoLists(self,l1:ListNode,L2:ListNode)->ListNode:
		if l1 is None:
			return l2
		elif l2 is None:
			return l1
		elif l1.val<l2.val:
			l1.next=self.mergeTwoLists(l1.next,l2)
			return l1
		else:
			l2.next=self.mergeTwoLists(l2.next,l1)
			return l2			

代码逻辑：第一层，对l1.val进行判断，谁小听谁的，目标是输出这个链表，那就要修改这个链表，在第一层的时候，是先进函数，再赋值，所以在第一层的时候还没进行赋值就已经进第二层了，在第二层的时候还没赋值就又进第三层了，以此类推，然后每一次都抛掉一个最小的数。
我想了下，我决定不管了，就跟二分法当时一样，我直接按逻辑走，谁小谁就去用他的next继续和他刚才的人比，同时输出他自己本身，完事了。
其实这个题我并不能力理解return后面这个数的数据类型到底是什么，输出的时候是列表形式，计算的时候又是单个形式，很奇怪。可能之后就理解了吧。

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        if list1 and list2:
            if list1.val > list2.val:
                list1, list2 = list2, list1
            list1.next = self.mergeTwoLists(list1.next, list2)

        return list1 or list2

方法二：迭代：

class Solution:
	def mergeTwoLists(self,l1:ListNode,l2:ListNode)->ListNode:
		prehead=ListNode(-1)
		prev=prehead
		while l1 and l2:
			if l1.val<=l2.val:
				prev.next=l1
				l1=l1.next
			else:
				prev.next=l2
				l2=l2.next
			prev=prev.next

3.链表的基本操作

is_empty()链表是否为空
length()链表长度
travel()遍历整个链表
add(item)链表头部添加元素
append(item)链表尾部添加元素
insert(pos,item)指定位置添加元素
remove(item)删除节点，从左到右删第一个
search(item)查找节点是否存在
他把next理解为指针，prev其实也是指针。

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

class SingleLinkList(object):
    def __init__(self,node=None):
        self._head=node    
    
    def is_empty(self):
        return self._head==None        

    def length(self):
        cur=self._head
        count=0 
        while cur!=None:
            count+=1
            cur=cur.next
        return count
    #cur是指针！！！


    def travel(self):
        cur=self._head
        while cur!=None:
            print(cur.elem)
            cur=cur.next
        return

    def add(self,item):
        node=Node(item)
        node.next=self._head
        self._head=node
    
    def append(self,item):
        node=Node(item)
        if self.is_empty():
            self._head=node
        else:
            cur=self._head
            while cur.next !=None:
                cur=cur.next
            cur.next=node

    def insert(self,pos,item):
        if pos<=0:
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            pre=self._head
            count=0
            while count<(pos-1):
                count+=1
                pre=pre.next
            node=Node(item)
            node.next=pre.next
            pre.next=node

    def remove(self,item):
        cur=self._head
        pre=None
        while cur!=None:
            if cur.elem==item:
                if cur==self._head:
                    self._head=cur.next
                else:
                    pre.next=cur.next
                break
            else:
                pre=cur
                cur=cur.next

    def search(self,item):
        cur=self._head
        while cur!=None:
            if cur.elem==item:
                return True
            else:
                cur=cur.next
        return False