python基本数据结构

栈 — 列表

列表为0为栈底，列表最后为栈顶

append 与 pop

class Stack():
    def __init__(self):
        self.items = []
    def push(self, item):
        self.items.append(item)
    def pop(self):
        return self.items.pop()
    def peek(self): # 返回栈顶元素，但不删除
        return self.items[-1]
    def isEmpty(self):
        return self.items == []
    def size(self):
        return len(self.items)
    
s = Stack()
s.push(1)
print(s.peek())

1

队列 — 列表

位置0为队尾，位置-1为队头 尾插(insert)头删(pop)

按1 2 3放入 得到队列[3 2 1]

insert 与 pop

class Queue():
    def __init__(self):
        self.items = []
    def enqueue(self, item):
        self.items.insert(0, item)  # 插入位置0
    def dequeue(self):
        return self.items.pop()  # 返回最后一个元素
    def size(self):
        return len(self.items)

q = Queue()
q.enqueue(1)
print(q.size())

1

链表

计算机作用： 对二进制数据进行存储和运算

self._head = node 代表_head指向了node所对应的内存空间

# 结点
class Node():
    def __init__(self, item):
        self.next = None
        self.item = item

# 链表
class Link():
    def __init__(self):
        self._head = None  # 指向链表中的头结点
    # 向链表头部插入结点
    def add(self, item):
        node = Node(item)
        node.next = self._head
        self._head = node
    # 遍历链表
    def travel(self):
        cur = self._head
        while cur:
            print(cur.item)
            cur = cur.next
    # 是否为空
    def is_empty(self):
        return self._head == None
    # 链表长度
    def length(self):
        cur = self._head
        num = 0
        while cur:
            num += 1
            cur = cur.next
        return num
    # 找是否存在某个元素
    def search(self, item):
        cur = self._head
        find = False
        while cur:
            if cur.item == item:
                find = True
                break
            cur = cur.next
        return find
    # 在链表尾插入
    def append(self, item):
        cur = self._head
        pre = None  # 指向cur的前一个结点
        if cur is None:
            self._head = Node(item=item)
        else:
            while cur:
                pre = cur
                cur = cur.next
            pre.next = Node(item=item)
    # 向对应位置插入值
    def insert(self, pos, item):  # pos 结点从0记
        node = Node(item)
        pre = None
        cur = self._head
        num = 0
        while cur:
            if num >= pos - 1:
                break
            cur = cur.next
            num += 1
            
        if num == pos - 1:
            node.next = cur.next
            cur.next = node
        elif pos == num: 
            """
            为空时，插入第一个结点  
            在c++里因为有空的头结点next属性，所以两个if可以合并
            python中没有空的头结点，所以只能使用两个if
            """
            self._head = node
        else:
            print('pos参数错误')
    # 删除某个结点
    def remove(self, pos):
        cur = self._head
        num = 0
        while cur:
            if num >= pos - 1:
                break
            cur = cur.next
            num += 1
            
        if num == pos - 1 and cur is not None and cur.next is not None:
            cur.next = cur.next.next
        elif pos == num and cur: 
            self._head = cur.next
        else:
            print('pos参数错误')
            

        

link = Link()
link.add(3)
link.add(4)
link.add(5)
link.travel()
# print('length: ', link.length())
# print(link.search(3))
# print()
# link.append(6)
# link.travel()
# print()
# link.insert(-1, 10)
print()
link.remove(1)
link.travel()

结果：

5
4
3

5
3

二叉树

遍历

• 广度遍历：逐层遍历
• 深度遍历：前序遍历，中序遍历，后序遍历

# 封装一个结点对象
class Node():
    def __init__(self, item):
        self.item = item
        self.left = None
        self.right = None

# 封装一个二叉树
class tree():
    def __init__(self):
        self.root = None
    # 向二叉树插入新的结点  找到子结点为空的子结点插入
    def addNode(self, item):
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        cur = self.root
        queue = [cur]
        while queue:
            n = queue.pop(0)
            if n.left is None:
                queue.append(n.left)
            else:
                n.left = node
                break
            if n.right is None:
                queue.append(n.right)
            else:
                n.right = node
                break
    # 广度遍历
    def trave():
        if self.root is None:
            print('root is none')
            break
        cur = self.root
        queue = [cur]
        while queue:
            n = queue.pop(0)
            print(n.item)
            if r.left is not None:
                queue.append(n.left)
            if r.right is not None:
                queue.append(n.right)
    # 前序遍历 先打印根
    def forword(self, root):
        if root:
            print(root.item)
            self.forword(root.left)
            self.forword(root.right)
    # 中序遍历
    def middle(self, root):
        if root:
            self.middle(root.left)
            print(root.item)
            self.middle(root.right)
    # 后序遍历
    def back(self, root):
        if root:
            self.back(root.left)
            self.back(root.right)
            print(root.item)
        

排序二叉树

插入结点：比根小的结点插入到做子树，比根结点大的结点插入到根的右侧

• 中序遍历会得到排序好的数据

class Node():
    def __init__(self, item):
        self.item = item
        self.left = None
        self.right = None
        
class SortTree():
    def __init__(self):
        self.root = None
    # 插入元素
    def insertNode(self, item):
        node = Node(item=item)
        # 树为空
        if self.root is None:
            self.root = node
            return
        # 树不为空
        cur = self.root
        while True:
            if node.item > cur.item:  # 往右插
                if cur.right is None:
                    cur.right = node
                    break
                else:
                    cur = cur.right
            else:
                if cur.left is None:
                    cur.left = node
                    break
                else:
                    cur = cur.left
    # 前序遍历 先打印根
    def forword(self, root):
        if root:
            print(root.item)
            self.forword(root.left)
            self.forword(root.right)
    # 中序遍历
    def middle(self, root):
        if root:
            self.middle(root.left)
            print(root.item)
            self.middle(root.right)
    # 后序遍历
    def back(self, root):
        if root:
            self.back(root.left)
            self.back(root.right)
            print(root.item)