数据结构（二）

数据结构中还有一种叫做栈，栈是限制在一段插入操作和删除操作的线性表，允许操作的一端称为栈顶，另一端称为栈底，当栈中没有元素的时候称为空栈，可以想象为一个容器，往里边不断的丢入元素，栈具有的规律就是先进后出或者后进先出。栈的顺序存储。
延续之前的同样创建类来对其进行操作

#　自定义栈异常
class StackError(Exception):
    pass
#　基于列表实现顺序栈
class SStack:
    def __init__(self):
        #　约定列表的最后一个元素为栈顶
        self._elems = []
    def top(self):
    	if not self._elems:
        raise StackError("stack is empty")
    return self._elems[-1]

第一个需要操作的就是判断这个栈是否为空，如果是空就返回一个True，如果不是就返回一个False。

#　判断栈是否为空
def is_empty(self):
    return self._elems == []

第二个入栈，在这个栈中放入某一个元素。

#　入栈
def push(self,elem):
    self._elems.append(elem)

第三个出栈，也成为弹栈，弹出某个一元素。

#　出栈
def pop(self):
    if not self._elems:
        raise StackError("stack is empty")
    return self._elems.pop()

测试代码！

while not st.is_empty():
    print(st.pop())

那么栈还有一种储存结构相当于我们的链表，第一个元素的next里边存储着下一个元素的地址。
和栈的存储方法一样不过在创建结点类的时候我饿看到多了一个next的值，初始化方法的时候就让next等于None就可以了，在查看的时候依旧遵循后进先出的原则。

#　自定义栈异常
class StackError(Exception):
    pass

# 创建结点类
class Node(object):
    def __init__(self, val, next=None):
        self.val = val  # 有用数据
        self.next = next

class LStack:
    def __init__(self):
        #　标记栈顶位置
        self._top = None

    def is_empty(self):
        return self._top is None

    def push(self,elem):
        self._top = Node(elem,self._top)

    def pop(self):
        if self._top is None:
            raise StackError("stack is empty")
        p = self._top
        self._top = p.next
        return p.val

    #　查看栈顶元素值
    def top(self):
        if self._top is None:
            raise StackError("stack is empty")
        return self._top.val
     #　将栈清空
    def clear(self):
   	 self._top = None

还有一种就是队列，队列是限制在两端进行插入操作和删除操作的线性表，允许存入的一端称为“队尾”允许删除的一端称为“队头”。只可以对对链表的队头和队尾进行操作。遵循后进后出的规律。
顺序队列，两端操作一端删除，一端添加。这里用到的都是append和pop方法！

# 　队列异常
class QueueError(Exception):
    pass
# 完成队列操作
class SQueue:
    def __init__(self):
        self._elems = []  # 使用列表存储队列数据

    def is_empty(self):
        return self._elems == []

    # 　入队
    def enqueue(self, elem):
        self._elems.append(elem)

    # 出队
    def dequeue(self):
        if not self._elems:
            raise QueueError("Queue is empty")
        return self._elems.pop(0)

链式队列

# 　队列异常
class QueueError(Exception):
    pass
# 队列结点类
class Node(object):
    def __init__(self, val, next=None):
        self.val = val  # 有用数据
        self.next = next
#　链式队列方法实现
class LQueue:
    def __init__(self):
        self.front = self.rear = Node(None)

    def is_empty(self):
        return self.front == self.rear

    #　入队
    def enqueue(self,elem):
        self.rear.next = Node(elem)
        self.rear = self.rear.next

    #　出队
    def dequeue(self):
        if self.front == self.rear:
            raise QueueError("Queue is empty")
        self.front = self.front.next
        return self.front.val

    #　清空队列
    def clear(self):
        self.front = self.rear

这就是数据结构中其他两个线性表，栈和队列。