数据结构-第七天

一、栈

"""
栈   方法  == 先进后出
    类似数组
        append
        pop
        函数
"""

class Stack:
    def __init__(self,size):
        # 初始化空数组，作为栈
        self.items = []
        self.size = size   # 栈长度的限定符

    def isEmpty(self):
        return len(self.items) == 0

    # 判断栈是否已满  True 表示栈已满
    def isFull(self):
        return len(self.items) == self.size

    # 入栈操作
    # 先判断栈是否已满，若满则报异常，中断后代码执行。未满则正常append
    def push(self,enments):
        if self.isFull():
            raise Exception('stack is full')  # 抛异常，后续的代码将不会执行
        else:
            self.items.append(enments)

    def pop(self):
        if self.isEmpty():
            raise Exception('stack is empty')

        return self.items.pop()   # 将最后的一位数字返回并删除

    # 返回栈顶的数值，但对栈不做操作
    def peek(self):
        if self.isEmpty():
            raise Exception('stack is empty')

        return self.items[-1]   # 将最后的一位数字返回

    def clear(self):
        return self.items.clear()

    def size(self):
        return len(self.items)  # 返回栈的长度

from python_demo.demo01 import add as add

if __name__ == '__main__':
#     s = Stack(5)
    c = add(1,2)
    print(c)
#     # 入栈
#     s.push(3)
#     s.push(4)
#     s.push(1)
#     s.push(2)
#     s.push(5)
#
#     print(s.peek())
#
#     print(s.pop())
#     print(s.pop())
#     print(s.pop())

二、链表

"""
    2024-10-28
        链表
            单向链表
                组成 data  == 数据
                    next  == 指针
                两部分构成
        其中头节点 data = None ；next = None/下一个node  （空链表//有数据的链表

"""
# 定义初始化节点
class Node():
    def __init__(self,data = None):
        if data is not None:
            self.data = data
        self.next = None

class Linkedlist():
    def __init__(self):
        # 初始化头节点
        head = Node()
        self.head = head

    # 链表的数据传输为data
    # 尾部数据增加
    def append(self,data):
        new_node = Node(data)   # 初始化新增的节点
        # 判断头节点后是否有数据节点
        # 如果头节点后没有其他节点，则新增加的节点作为头节点的后续节点
        if self.head.next is None:
            self.head.next = new_node   # 函数返回 后面代码不执行
            return
        # 如果头节点后有数据节点，遍历链表，找到尾部的节点进行新节点的增加
        node = self.head   # 找到头节点的下一个节点
        while node.next is not None:  # 对节点的next进行对比，找到链表的末尾
            node = node.next

        # 在链表的末尾，将节点的下一个指针为new_node
        node.next = new_node

    # 数据的展示
    def display(self):
        node = self.head.next  # 头节点没有data，先找到头节点后的第一个节点，遍历输出data
        while node is not None:   # 判断当前node对象是否为空
            print(node.data)
            node = node.next

    # 头部data数据插入
    def prepend(self,data):
        new_node = Node(data)  # 初始化新增的节点
        # 头节点后没有数据，则head next = new node
        if self.head.next is None:
            self.head.next = new_node

        # 如果头节点后有数据 则变换指针方向。先将新节点的next指向头节点的next，后将头节点的next指向新节点new_node
        new_node.next = self.head.next
        self.head.next = new_node

    def remove(self,data):  # 删除data的节点，后续节点向前移位
        # 对链表进行空链表判定
        if self.head.next is None:
            raise Exception('linkedlist is null!')
        # 进行链表删除
        node = self.head   # 找到头节点
        while node.next.data != data:  # 对下一个节点的data进行判断，
            node = node.next
        node.next = node.next.next   # 当前节点的next = 当前节点的next的next节点

if __name__ == '__main__':
    l = Linkedlist()
    l.append(1)
    l.append(2)
    l.append(3)

    l.display()
    print('-----------')
    l.prepend(4)
    l.display()
    print('-----------------')
    l.remove(4)
    l.display()

三、二叉树

# 定义二叉查找树的树节点
class Node():
    def __init__(self,key):
        self.key = key
        self.left_next = None
        self.right_next = None
# 创建二叉树结构
class Bst():
    def __init__(self):
        # 初始化根节点
        self.root = None

    # 创建根节点 == 从根节点开始
    def creat_root_insert(self,key):
        if self.root is None:
            self.root = Node(key)
        # 如果根节点不为空，则进行遍历进行节点 的插入
        else:
            self._creat_mid_insert(self.root,key)   # 遍历 递归迭代进行节点插入

    # 进行节点遍历，子节点数据插入
    def _creat_mid_insert(self,node,key):
        if node.key > key:
            # 如果要插入的节点key与root_key进行比较，若root_key 为空则直接进行节点插入
            # 若root_key不为空，则key<root_key,则走左子树进行遍历，递归插入；若key>root_key,则走右子树进行遍历，递归插入。
            # 左子树进行程序遍历
            if node.left_next is None:
                node.left_next = Node(key)
            else:  # 如果左子树不为空，进行左子树遍历，找到末尾进行节点插入
                self._creat_mid_insert(node.left_next,key)
        elif node.key < key:
            # 右子树进行程序遍历
            if node.right_next is None:
                node.right_next = Node(key)
            else:  # 如果右子树不为空，进行右子树遍历，找到末尾进行节点插入
                self._creat_mid_insert(node.right_next, key)

    # 对二叉树进行遍历 == 中序遍历 左 中  右 三个方向进行数据遍历
    def inorder_search(self):
        # 创建输出的结果集，将结果进行存储后整体返回
        result = []
        self._inorder_search(self.root,result)
        return result

    def _inorder_search(self,node,result):
        if node:
            self._inorder_search(node.left_next,result)
            result.append(node.key)
            self._inorder_search(node.right_next, result)

    # 对二叉树进制前序遍历  == 中 左 右
    def pro_search(self):
        result = []
        self._pro_search(self.root,result)
        return result

    def _pro_search(self,node,result):
        if node:
            result.append(node.key)
            self._pro_search(node.left_next,result)
            self._pro_search(node.right_next,result)


    # 后序遍历 ==  左子树 右子树 根节点
    def late_search(self):
        result = []
        self._pro_search(self.root,result)
        return result

    def _late_search(self,node,result):
        if node:
            self._pro_search(node.left_next,result)
            self._pro_search(node.right_next,result)
            result.append(node.key)

    # 节点数据删除操作
    def remove(self,key):
        self.root = self._remove(self.root,key)

    def _remove(self,node,key):
        if node is None:
            return None

        if key < node.key:  # 往左走
            node.left_next = self._remove(node.left_next,key)

        elif key > node.key:  # 往右走
            node.right_next =  self._remove(node.right_next,key)

        # 递归终止条件 == 返回节点
        else:
            # key = node.key
            # 1、如果当前node下面没有子节点，则当前node返回None
            if node.left_next is None and node.right_next is None:
                return None
            # 2.1、当前节点没有左节点，则返回右节点作为当前节点
            elif node.left_next is None:
                return node.right_next
            # 2.2、当前节点没有右节点，则返回左节点作为当前节点
            elif node.right_next is None:
                return node.left_next
            # 3、当前节点有两个子节点，则找当前节点的右子树中最小的左子树，找到最小值作为当前节点
            #   最后删除最小值节点
            else:
                # 删除节点 == 左右都有节点，则遍历当前节点的right_next,找到right_next 中 最小的left_next
                right_min_left_next = self._min_left_next(node.right_next)  # 将最小值节点替换为当前节点
                node.key = right_min_left_next.key
                node.right_next = self._remove(node.right_next,node.key)   # 将最小值节点进行删除
                # 返回右子树中最小的左子树节点
        return node
    # 找到node右子树中最小的左子树的node 返回
    def _min_left_next(self,node):
        while node.left_next is not None:
            node = node.left_next
        return node


if __name__ == '__main__':
    bst = Bst()
    bst.creat_root_insert(5)
    bst.creat_root_insert(3)
    bst.creat_root_insert(2)
    bst.creat_root_insert(8)
    bst.creat_root_insert(10)
    bst.creat_root_insert(6)


    print(bst.inorder_search())

    bst.remove(8)
    print(bst.inorder_search())