python实现栈、队列、链表和二叉树

 

数组是最基本的数据结构，栈、队列、链表和二叉树都可以视为基于数组的典型数据结构。

 

1. 栈在python语言中的实现：

class Stack(object):   def __init__(self):     self._top = 0   # 可以理解为C语言中的栈顶指针     self._stack = []  # 列表（等同于C语言中的数组）。这里就体现了数组是最基本的数据结构了。   def put(self, data): # 入栈函数     self._stack.insert(self._top, data)     self._top += 1   def pop(self):  # 出栈函数     if self.isEmpty():       raise ValueError('stack 为空')     self._top -= 1     data = self._stack[self._top]     return data   def isEmpty(self):     if self._top == 0:       return True     else:       return False   def __str__(self):     return "Stack(%s)"%self._stack

 

上面几行代码就说明了一个很简洁却又很深刻的事实——一个栈顶指针（可直接视为索引），一个列表，一个入栈函数，一个出栈函数就构成了一个栈结构。

2. 队列在python语言中的实现：

class Queue(object):   def __init__(self, max_size=float('inf')):     self._max_size = max_size     self._top = 0     self._tail = 0     self._queue = []   def put(self, value):     if self.isFull():       raise ValueError("the queue is full")     self._queue.insert(self._tail, value)     self._tail += 1   def pop(self):     if self.isEmpty():       raise ValueError("the queue is empty")     data = self._queue.pop(self._top)     self._top += 1     return data   def isEmpty(self):     if self._top == self._tail:       return True     else:       return False   def isFull(self):     if self._tail == self._max_size:       return True     else:       return False   def __str__(self):     return "Queue(%s)"%self._queue

3.二叉树

class Node:   def __init__(self,item):     self.item = item     self.child1 = None     self.child2 = None class Tree:   def __init__(self):     self.root = None   def add(self, item):     node = Node(item)     if self.root is None:       self.root = node     else:       q = [self.root]       while True:         pop_node = q.pop(0)         if pop_node.child1 is None:           pop_node.child1 = node           return         elif pop_node.child2 is None:           pop_node.child2 = node           return         else:           q.append(pop_node.child1)           q.append(pop_node.child2)   def traverse(self): # 层次遍历     if self.root is None:       return None     q = [self.root]     res = [self.root.item]     while q != []:       pop_node = q.pop(0)       if pop_node.child1 is not None:         q.append(pop_node.child1)         res.append(pop_node.child1.item)       if pop_node.child2 is not None:         q.append(pop_node.child2)         res.append(pop_node.child2.item)     return res   def preorder(self,root): # 先序遍历     if root is None:       return []     result = [root.item]     left_item = self.preorder(root.child1)     right_item = self.preorder(root.child2)     return result + left_item + right_item   def inorder(self,root): # 中序序遍历     if root is None:       return []     result = [root.item]     left_item = self.inorder(root.child1)     right_item = self.inorder(root.child2)     return left_item + result + right_item   def postorder(self,root): # 后序遍历     if root is None:       return []     result = [root.item]     left_item = self.postorder(root.child1)     right_item = self.postorder(root.child2)     return left_item + right_item + result     t = Tree()  # 实例化对象 for i in range(10):   t.add(i) print('层序遍历:',t.traverse()) print('先序遍历:',t.preorder(t.root)) print('中序遍历:',t.inorder(t.root)) print('后序遍历:',t.postorder(t.root))

 

4. 链表

class jd():
    def __init__(self,data):
        self.data=data
        self.next=None
    
class Linklist():
    def __init__(self,jd2):
        self.head=jd2
        self.head.next=None
        self.tail=self.head

    def add(self,jd2):
        self.tail.next=jd2
        self.tail=self.tail.next

    def view(self):
        jd2=self.head
        linkstr=""
        while jd2 is not None:
            if jd2.next is not None:
                linkstr=linkstr+str(jd2.data)+"-->"
            else:
                linkstr+=str(jd2.data)
            jd2=jd2.next
        print linkstr