python实现数据结构与算法

数据结构

栈和队列

class Stack:
“”"
栈的特点:先进后出
栈的应用场景: 1. 撤销操作 2. 网页的前进和后退
栈的实现：1.列表（顺序结构） 2.链表
“”"
def init(self):
self.stack=[]

def push(self,element):
    self.stack.append(element)

def pop(self):
    return self.stack.pop()

def top(self):
    if self.is_empty():
        return "stack is empty"
    # return self.stack.pop()
    return self.stack[-1]

def is_empty(self):
    if len(self.stack)==0:
        return True
    return False

def size(self):
    return len(self.stack)

class Queue:
“”"
# 队列的特点: 先进先出
# 队列的应用场景: 1. 消息队列 2. 进程池 3。 线程池
# 队列的实现: 1. 列表(顺序结构) 2。链表
“”"
def init(self):
self.queue=[]

def enqueue(self,ele):
    self.queue.append(ele)

def dequeue(self):
    return self.queue.pop(0)

def empty(self):
    return self.queue==[]

def size(self):
    return len(self.queue)

if name == ‘main’:
stack=Stack()
stack.push(1)
stack.push(2)
stack.push(3)
print(stack.stack)
stack.pop()
print(stack.stack)
print(stack.top())
print(stack.size())
print(stack.is_empty())
stack.pop()
stack.pop()
print(stack.top())
print(stack.is_empty())
print(stack.size())
print(stack.stack)
print(‘-’*50)
queue=Queue()
queue.enqueue(1)
queue.enqueue(2)
queue.enqueue(3)
print(queue.queue)
queue.dequeue()
queue.dequeue()
print(queue.queue)

队列进阶（用链表实现）

单链表如下：
import random

class Node:
def init(self, data):
self.data = data
self.next = None

class LinkList:
def init(self):
self.head = None
self.length = 0

def tail_insertion(self, data):
    node = Node(data)
    if self.head is None:
        self.head = node
        self.length += 1
        return
    cur = self.head
    while cur.next:
        cur = cur.next
    cur.next = node
    self.length += 1

def insert(self, index, data):
    node = Node(data)
    cur = self.head
    if index == 0:
        node.next = cur
        self.head = node
        self.length += 1
    elif index == self.length:
        for i in range(index - 1):
            cur = cur.next
        cur.next = node
        node.next = None
        self.length += 1
    elif 0 < index < self.length:
        for i in range(index - 1):
            cur = cur.next
        node.next = cur.next
        cur.next = node
        self.length += 1
    else:
        return '请重新输入'

def remove(self, data):
    cur = self.head
    pre = None
    while cur:
        if cur.data == data:
            if cur == self.head:
                self.head = cur.next
                self.length -= 1
            else:
                pre.next = cur.next
                self.length -= 1
            break
        else:
            pre = cur
            cur = cur.next

def traverse(self):
    cur = self.head
    while cur:
        print(cur.data, end=' ')
        cur = cur.next

def length(self):
    return self.length()

def search(self, data):
    count = 0
    cur = self.head
    while cur:
        if cur.data == data:
            return count
        cur = cur.next
        count += 1
    return '没找到对应数据'

if name == ‘main’:
linklist = LinkList()
for i in range(6):
linklist.tail_insertion(random.randint(1, 10))
linklist.traverse()
print()
print(linklist.length)
linklist.insert(3, 65)
print()
linklist.traverse()
linklist.remove(2)
print()
linklist.traverse()
print()
index = linklist.search(3)
print(index)
print(linklist.length)

双端队列 内部结构是用双向链表
from collections import deque

#增删查改
双端队列是用双向链表实现的
queue = deque([“Eric”, “John”, “Michael”])
queue.append(‘luke’)
print(queue)
print(queue.popleft())
print(queue)
print(queue.pop())
print(queue)
queue.insert(0, ‘jack’)
print(queue)

循环队列

#rear始终指向要放的元素的位置
#出队始终是front指向的元素
import random

class CircleQueue:
def init(self, max_size):
self.front = 0
self.rear = 0
self.list = [0] * max_size
self.max_size = max_size

def is_full(self):
    if (self.rear + 1) % self.max_size == self.front:
        return True
    return False

def is_empty(self):
    if self.rear == self.front:
        return True
    return False

def enqueue(self, data):
    if self.is_full():
        print('队列已满')
        return False
    self.list[self.rear] = data
    self.rear = (self.rear + 1) % self.max_size
    return True

def dequeue(self):
    if self.is_empty():
        print('队列已空')
        return False
    out_data = self.list[self.front]
    self.list[self.front] = 0
    self.front = (self.front + 1) % self.max_size
    return out_data

def size(self):
    return (self.rear - self.front + self.max_size) % self.max_size

if name == ‘main’:
ciclequeue = CircleQueue(6)
for i in range(5):
ciclequeue.enqueue(random.randint(1, 10))
print(ciclequeue.list)
data = ciclequeue.dequeue()
print(data)
ciclequeue.enqueue(20)
print(ciclequeue.list)
# ciclequeue.enqueue(15)
# print(ciclequeue.list)

树

二叉树建树与四种遍历

class Node:
def init(self, element=-1, lchild=None, rchild=None):
self.element = element
self.lchild = lchild
self.rchild = rchild

class Tree:
def init(self):
self.tree_root = None
self.my_queue = []

def build_tree(self, data):
    new_node = Node(data)
    # 进队列
    self.my_queue.append(new_node)
    if self.tree_root is None:  # 如果树根为空，让new_node作为树根
        self.tree_root = new_node
        return True
    else:
        # 树不为空
        if self.my_queue[0].lchild is None:
            self.my_queue[0].lchild = new_node
            return True
        elif self.my_queue[0].rchild is None:
            self.my_queue[0].rchild = new_node
            self.my_queue.pop(0)

def pre_order(self, node: Node):
    if node:
        print(node.element, end='')
        self.pre_order(node.lchild)
        self.pre_order(node.rchild)

def mid_order(self, node: Node):
    if node:
        self.mid_order(node.lchild)
        print(node.element, end='')
        self.mid_order(node.rchild)

def post_order(self, node: Node):
    if node:
        self.post_order(node.lchild)
        self.post_order(node.rchild)
        print(node.element, end='')

def level_order(self):
    self.my_queue.clear()
    self.my_queue.append(self.tree_root)
    while self.my_queue:
        node = self.my_queue.pop(0)
        print(node.element, end='')
        if node.lchild:
            self.my_queue.append(node.lchild)
        if node.rchild:
            self.my_queue.append(node.rchild)
    return True

#测试驱动开发，先把测试代码写好，再写功能
if name == ‘main’:
tree = Tree()
for i in ‘abcdefghij’:
tree.build_tree(i)
print(‘前序遍历：’, end=‘’)
tree.pre_order(tree.tree_root)
print()
print(‘中序遍历：’, end=‘’)
tree.mid_order(tree.tree_root)
print()
print(‘后序遍历：’, end=‘’)
tree.post_order(tree.tree_root)
print()
print(‘层序遍历：’, end=‘’)
tree.level_order()