python实现栈、队列、链表

实现栈

class Stack(object):
    """
    栈
    """
    # 创建新栈
    def __init__(self):
        self.stack = []
        pass
    # 添加元素到栈顶
    def push(self,item):
        self.stack.append(item)
        pass
    # 弹出栈顶元素
    def pop(self):
        return self.stack.pop()
    # 返回栈顶元素
    def top(self):
        # 判断是否是空栈
        if self.stack:
            return self.stack[-1]
        return None
    # 判断栈是否为空
    def is_empty(self):
        return self.stack==[]
    # 返回栈中元素的个数
    def length(self):
        return len(self.stack)
    pass

实现队列

class Queue():
    # 创建一个新的队列
    def __init__(self):
        self.queue = []
    # 向队列中添加一个新元素
    def put(self,item):
        self.queue.insert(0,item)
        pass
    # 从队列中删除一个元素
    def get(self):
        return self.queue.pop()
    # 判断队列是否为空
    def is_empty(self):
        return self.queue == []
    # 返回队列大小
    def size(self):
        return len(self.queue)

实现链表

# 定义节点类
class Node():

    def __init__(self,elem):
        self.elem = elem
        # 一开始不知道节点的链接去指向谁，所以，让其值为None
        self.next = None

# 定义链表类
class LinkList():

    # 为了能够让第一个节点挂到链表上，需要使用一个头结点指向第一个节点
    def __init__(self,node=None):
        self.head = node

    # 1. 链表是否为空
    def is_empty(self):
        return self.head == None

    # 2. 计算链表的长度
    def length(self):
        # 判断特殊情况：空链表情况
        # 定义游标，用于遍历整个链表中的节点
        cur = self.head
        # 定义计数器
        count = 0
        # 开始移动，一直移动
        while cur != None:
            count += 1
            # 移动游标
            cur = cur.next
        return count

    # 3. 遍历链表
    def travel(self):
        # 和计算长度差类似
        # 创建游标
        cur = self.head
        while cur != None:
            print(cur.elem,end=' ')
            # 进行移动
            cur = cur.next
        print()

    # 4. 链表头部添加元素(头插法)
    def add(self,item):
        # 创建一个新节点
        node = Node(item)
        # 改变指向
        node.next = self.head
        self.head = node
        # 考虑空链表情况
        pass

    # 5. 链表尾部添加元素(尾插法)
    def append(self,item):
        # 构造一个节点
        node = Node(item)
        # 判断空链表
        if self.is_empty():
            self.head = node
            pass
        else:
            # 定义游标
            cur = self.head
            while cur.next != None:
                cur = cur.next
            cur.next = node

    # 6. 链表指定位置添加元素
    def insert(self,index,item):
        # 判断添加位置
        if index <= 0:
            #  头部添加
            self.add(item)
            pass
        elif index > (self.length()-1):
            # 尾插法
            self.append(item)
        else:
            # 创建游标
            cur = self.head
            count = 0
            while count < (index-1):
                count += 1
                # 移动游标
                cur = cur.next
            # 创建一个节点
            node = Node(item)
            # 改变指向
            node.next = cur.next
            cur.next = node
        pass

    # 7. 链表删除指定节点
    def remove(self,item):
        # 考虑特殊情况:
        # 1. 空链表
        # 2. 删除的元素是第一个节点
        # 3. 删除的元素是尾结点
        # 创建两个游标
        cur = self.head
        por = None
        while cur != None:
            if cur.elem == item:
                # 判断是否是第一个节点
                if cur == self.head:
                    self.head = cur.next
                    pass
                else:
                    por.next = cur.next
                break
            else:
                # 移动
                por = cur
                cur = cur.next

    # 8. 查找节点是否存在
    def search(self,item):
        # 创建游标
        cur = self.head
        while cur != None:
            # 判断是否相等
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        # 循环退出以后
        return False