栈的实现

class Stack(object):                                    // 定义类
    def __init__(self, limit=10):            // 定义方法
        self.stack = []                                 // 存放元素
        self.limit = limit                              // 栈容量极限
    def push(self, data):                               // 判断入栈
        if len(self.stack) >= self.limit:        // 判断栈是否溢出
            print('StackOverflowError')
            pass
        self.stack.append(data)             // append 函数 ？函数的实现有待研究
    def pop(self):                    // 定义出栈
        if self.stack:
            return self.stack.pop()            //  pop data
        else:
            raise IndexError('pop from an empty stack') // 空栈不能被弹出
    def peek(self):                                     //查看堆栈的最上面的元素
        if self.stack:
            return self.stack[-1]
    def is_empty(self):                                 //判断栈是否为空
        return not bool(self.stack)
    def size(self):                                     //返回栈的大小
        return len(self.stack)

单链表

class Node:                                //定义类 
    def __init__(self, data):                        //方法
        self.data = data
        self.next = None
class Linked_List:
    def __init__(self):
        self.head = None
    def initlist(self,data_list):    #链表初始化函数
        self.head=Node(data_list[0])   #创建头结点
        temp=self.head
        for i in data_list[1:]: #逐个为 data 内的数据创建结点, 建立链表
            node=Node(i)
            temp.next=node
            temp=temp.next
    def is_empty(self):  #判断链表是否为空
        if self.head.next==None:
            print("Linked_list is empty")
            return True
        else:
            return False
    def get_length(self):  #获取链表的长度
        temp=self.head #临时变量指向队列头部
        length=0 #计算链表的长度变量
        while temp!=None:
            length=length+1
            temp=temp.next
        return length #返回链表的长度
    def insert(self,key,value): #链表插入数据函数
        if key<0 or key>self.get_length()-1:
            print("insert error")
        temp=self.head
        i=0
        while i<=key: #遍历找到索引值为 key 的结点后, 在其后面插入结点
            pre=temp
            temp=temp.next
            i=i+1
        node=Node(value)
        pre.next=node
        node.next=temp
    def print_list(self):   #遍历链表，并将元素依次打印出来
        print("linked_list:")
        temp=self.head
        new_list=[]
        while temp is not None:
            new_list.append(temp.data)
            temp=temp.next
        print(new_list)
    def remove(self,key):  #链表删除数据函数
        if key<0 or key>self.get_length()-1:
            print("insert error")
        i=0
        temp=self.head
        while temp !=None:  #遍历找到索引值为 key 的结点
            pre=temp
            temp=temp.next
            i=i+1
            if i==key:
                pre.next=temp.next
                temp=None
                return True
        pre.next=None
    def reverse(self): #将链表反转
        prev = None
        current = self.head
        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node
        self.head = prev