链表、队列、栈、二叉树（Python描述）

链表、队列、栈、树（Python描述）

前言：1、实现一个与python中list对象一样的功能的链表。2、python中的list 对象为顺序结构列表，类似于C的数组。文中队列/栈的实现以list实现。

一、链表

# 节点全部定义为内部类。实现链表基本操作，实现 变量名[index]的方式获取元素，实现切片返回链表，以及python中的迭代器。
class LinkedList():
    # 单链表
    class Node():
        # 节点类
        def __init__(self, item):
            self.item = item
            self.next = None
            
    def __init__(self):
        # 初始化头部为None
        self.head = None
        self.length = 0
        
    def headadd(self, item):
        """头部插入
        """
        # 创建新节点
        new_node = self.Node(item)
        # 头节点的地址赋值给 新节点的next
        new_node.next = self.head
        # 头节点再指向新节点
        self.head = new_node
        self.length += 1
        
    def append(self, item):
        """尾部插入
        """
        new_node = self.Node(item)
        p = self.head
        if not p:
            self.head = new_node
            self.length += 1
            return
        # 循环指向next直到next == None 即找到了尾部
        while p:
            if p.next:
                p = p.next
            else:
                break
        p.next = new_node
        self.length += 1
        
    def insert(self,item,index):
        """指定下标插入
        """
        if index-1 <=0:
            self.headadd(item)
            
        elif index-1 >= self.length-1:
            self.append(item)
            
        else:
            new_node = self.Node(item)
            p = self.head
            pi = 0
            while pi != index-1:
                p = p.next
                pi += 1
            new_node.next = p.next
            p.next = new_node
            
            self.length += 1
        
    def travel(self):
        """遍历打印链表
        """
        p = self.head
        if not p:
            print(p)
            return
        print()
        while True:
            print(p.item, end='->')
            p = p.next
            if not p:
                break
        print()
        
    def pop(self,index=None):
        if index == None:
            index = self.length-1
            
        if index >= self.length or index <0:
            raise Exception("下标越界")
            
        elif index == 0:
            result = self.head.item
            self.head = self.head.next
            self.length -= 1
            return result
            
        p = self.head
        pi = 0
        while pi != index-1:
            p = p.next
            pi += 1
            
        if index != self.length-1:
            result = p.next.item
            p.next = p.next.next
            self.length -= 1
            return result
        else:
            result = p.next.item
            p.next = None
            self.length -= 1
            return result
        
    def __getitem__(self,index):
        """ 重写__getitem__方法实现 变量名[index] 的方式获取元素
        """
        if isinstance(index, int):
            if index <0 or index >= self.length:
                raise Exception("下标越界")
        
            p = self.head
            pi = 0
            while p and pi != index:
                p = p.next
                pi += 1
            return p.item
        
        elif isinstance(index, slice):
             # 为了使用上的习惯，实现与python的list切片一样，左闭右开
            start = index.start
            stop = index.stop
            step = index.step
            if start == None:
                start = 0
            if stop == None:
                stop = self.length
            if step == None:
                step = 1
            
            if start <0 or stop > self.length:
                raise Exception("下标越界")
            
            site = start
            p = self.head
            pi = 0
            temp = LinkedList() # 创建一个链表对象
            while p and site < stop:
                if pi < start:
                    p = p.next
                    pi += 1
                elif pi == site:
                    temp.append(p.item)
                    p = p.next
                    pi += 1
                    site += step
                    
                else:
                    for i in range(step):
                        p = p.next
                        pi += 1
                
            return temp
        
        else:
            raise Exception("[int] or [slice]")
            
    # 下面重写__inter__() 和 __next__() 实现迭代器功能
    def __iter__(self):
        setattr(self,"_p",self.head) # 给对象定义个 p 属性，作为指针使用
        return self

    def __next__(self):
        if self._p != None:
            item = self._p.item
        else:
            raise StopIteration
        self._p = self._p.next
        return item

# 测试
li = LinkedList()
for i in range(5,11):
    li.headadd(i)

li.travel()

10->9->8->7->6->5->

li1 = LinkedList()
for i in range(5,11):
    li1.append(i)
    
li1.travel()
print(li1.length)

5->6->7->8->9->10->
6

for i in range(0,li1.length):
    li1.insert(100,i+i)
    
li1.travel()

100->5->100->6->100->7->100->8->100->9->100->10->

print(li1.pop(0))
print(li1.pop(1))
print(li1.pop(li1.length-2))

for i in range(li1.length):
    print(li1.pop(),"len"+str(li1.length), end=' --')
print()
li1.travel()

100
100
100
10 len8 --9 len7 --100 len6 --8 len5 --100 len4 --7 len3 --100 len2 --6 len1 --5 len0 --
None

li = LinkedList()
for i in range(5):
    li.append(i+2)
    
for each in li:
    print(each, end="-->")

2-->3-->4-->5-->6-->

a = li[1:5]
a.travel()
b = li[:3]
b.travel()
c = li[:]
c.travel()

3->4->5->6->

2->3->4->

2->3->4->5->6->

二、队列

# 队列，先进先出。使用python 自带的顺序表结构的list 实现队列
class Queue():
    def __init__(self):
        self.__queue = []
        
    def enqueue(self, item):
        # 尾部插入
        self.__queue.append(item)
        
    def dequeue(self):
        # 尾部取出
        return self.__queue.pop()
        
    def is_empty(self):
        return self.__queue == []

q = Queue()
for i in range(5):
    q.enqueue(i)
    print(i, end="-->")

print()
while not q.is_empty():
    print(q.dequeue(), end='-->')

0-->1-->2-->3-->4-->
4-->3-->2-->1-->0-->

三、栈

# 栈先进后出。使用list实现
class Stack():
    def __init__(self):
        self.stack = []
        
    def is_empty(self):
        return self.stack == []
    
    def push(self, item):
        # 入栈
        self.stack.append(item)
    
    def pop(self):
        # 出栈
        return self.stack.pop(0)
    

s = Stack()
for i in range(5):
    s.push(i)
    print(i, end="-->")
print()
while not s.is_empty():
    print(s.pop(),end="-->")

0-->1-->2-->3-->4-->
0-->1-->2-->3-->4-->

四、二叉树

class Tree():
    class Node():
        def __init__(self, item):
            self.item = item
            self.left = None
            self.right = None
    def __init__(self):
        self.root = None
        
    def add(self, item):
        new_node = self.Node(item)
        if self.root == None:
            self.root = new_node
            return
        
        queue = [self.root]
        while queue:
            node = queue.pop(0)
            if node.left == None:
                node.left = new_node
                return
            if node.right == None:
                node.right = new_node
                return
            queue.append(node.left)
            queue.append(node.right)
        
    def tarvel(self):
        """层次遍历
        """
        if self.root == None:
            print(None)
            return
        queue = [self.root]
        print()
        while queue:
            node = queue.pop(0)
            print(node.item,end='->')
            if node.left == None:
                print(None,end='->')
            else:
                queue.append(node.left)
            if node.right == None:
                print(None,end='->')
            else:
                queue.append(node.right)
        print()

t = Tree()
for i in range(5):
    t.add(i)
    
t.tarvel()

0->1->2->None->None->3->None->None->4->None->None->