栈和链表Day22

1.概念

数据结构是计算机科学中的一个核心概念，它是指数据的组织、管理和存储方式，以及数据元素之间的关系。数据结构通常用于允许高效的数据插入、删除和搜索操作。

数据结构大致分为几大类：

线性结构：数组、链表、栈、队列等。

非线性结构：树、二叉树、堆、图等。

散列：哈希表。

索引：B树、B+树等。

2.常见数据结构

2.1 栈

栈（stack），它是一种运算受限的线性表，遵循后进先出（Last In First Out，LIFO）原则的数据结构。

• LIFO(last in first out)表示就是后进入的元素, 第一个弹出栈空间. 类似于自动餐托盘, 最后放上的托盘, 往往先把拿出去使用.
• 其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
• 向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；
• 从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈常见的操作

• push(element): 添加一个新元素到栈顶位置.
• pop()：移除栈顶的元素，同时返回被移除的元素。
• peek()：返回栈顶的元素，不对栈做任何修改（这个方法不会移除栈顶的元素，仅仅返回它）。
• isEmpty()：如果栈里没有任何元素就返回true，否则返回false。
• clear()：移除栈里的所有元素。
• size()：返回栈里的元素个数。这个方法和数组的length属性很类似。

class stack:
    def __init__(self, size):
        # 初始化一个空数组作为栈
        self.items = []
        # 给数组设置一个容量阈值
        self.size = size

    # 判断栈是否为空，True为空，False非空
    def isEmpty(self):
        return len(self.items) == 0

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

    # 入栈操作
    # 判断栈是否已满，已满则抛栈已满异常，中断后面的代码执行
    # 否则向栈的尾部添加一个元素
    def push(self, item):
        if self.isFull():
            raise Exception('栈已满')
        self.items.append(item)

    # 出栈操作
    # 判断栈是否为空，是则抛栈已空异常
    # 否则从数组尾部移除一个元素，并将该元素返回
    def pop(self):
        if self.isEmpty():
            raise Exception('栈已空')
        return self.items.pop()

    # 从栈中获取栈顶的元素
    def peek(self):
        if self.isEmpty():
            raise Exception('栈已空')
        return self.items[-1]


if __name__ == '__main__':
    s = stack(5)
    s.push(3)
    s.push(4)
    s.push(5)
    s.push(1)
    # s.push(2)
    # s.push(6)
    # print(s.peek())
    # print(s.peek())
    # print(s.pop())
    # print(s.pop())
    # print(s.pop())
    # print(s.pop())
    # print(s.pop())
    # print(s.pop())
    print(s.isFull())

2.2 链表

链表是一条相互链接的数据节点表。每个节点由两部分组成：数据和指向下一个节点的指针。

2.1 链表的优缺点

优点：

1. 物理存储单元上非连续，而且采用动态内存分配，能够有效的分配和利用内存资源；
2. 节点删除和插入简单，不需要内存空间的重组。

缺点：

1. 不能进行索引访问，只能从头结点开始顺序查找；
2. 数据结构较为复杂，需要大量的指针操作，容易出错。

2.2 单向链表

2.2.1 插入

尾部插入

从头结点开始逐个遍历链表，直到找到next=null，表示为最后一个节点，再将最后节点的next指向新增节点。

头部插入

如果头节点的next=null表示链表为空，直接将头节点的next指向新增节点

如果头节点的next!=null，表示头节点后已存在后续节点，需要将新增节点插入到头节点和后续节点中间：

1.获取头节点的后续节点，定义一个临时节点，将该节点指向临时节点

2.将头节点的next指向新增节点

3.新增节点的next指向临时节点

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

    def append(self, data):
        new_node = Node(data)
        # 判断头节点后是否有数据节点，没有则直接将新节点链接到头节点后
        if self.head.next is None:
            self.head.next = new_node
            return
        # 如果头节点后面有数据节点，则遍历链表，找到next为None的数据节点（尾部节点），将新节点连接到尾部节点
        node = self.head.next
        while True:
            if node.next is None:
                break
            node = node.next
        # 将尾部节点的next指针指向新节点
        node.next = new_node

    def display(self):
        node = self.head.next
        while node is not None:
            print(node.data)
            node = node.next

    def prepend(self,data):
        new_data=Node(data)
        #如果头节点后没有节点，则将新节点插入到头节点后
        if self.head.next is None:
            self.head.next=new_data
        #如果头节点后有节点数据，则先将新节点的next指针指向头节点后一个节点，再将头节点next指针指向新节点
        new_data.next=self.head.next
        self.head.next=new_data

    def remove(self,data):
        node= self.head

        while node.next.data!=data:
            node=node.next
        node.next=node.next.next

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

    linkedList.display()

    linkedList.prepend(4)
    linkedList.prepend(5)
    linkedList.display()

    linkedList.remove(4)
    print('---')
    linkedList.display()
ist.append(3)

    linkedList.display()

    linkedList.prepend(4)
    linkedList.prepend(5)
    linkedList.display()

    linkedList.remove(4)
    print('---')
    linkedList.display()