栈：

python中没有指针，所以通过链表实现栈时，使用静态链表来模拟真正链表。栈的原理其实很简单，无非就是“先进后出”也就是说在入栈和出栈时，都是对栈顶元素进行操作，那说到这里就已经很清晰了，定义栈的”指针“时，我们只需要定义一个栈顶指针就可以完成入栈以及出栈的操作。

（入栈方向和出栈方向相反）
代码实现过程：
1.在用链表进行表示时，首先要声明一个方法，为它开创一个节点空间。
2.定义top”指针“。（为入栈出栈做准备）
3.入栈：判断是否为空栈，若为空栈，直接让top指针移动到新元素n即可。
需要注意的时，因为节点结构是分为data域和指向域，所以在入栈时，要分别对这两个域进行改变，又因为是将新元素加到栈顶，所以先让n的指向域指向top指针，目的是让新元素成为栈顶元素（操作指向域），再将top指针移动到n（赋值data域）
4.出栈：依旧是先判断是否为空栈，空即top指针指向为None则此时返回None即可。若不为空栈，仍类似于上述入栈需对指向域和数据域进行改变。首先定义临时变量让其=栈顶元素，因为是出栈，所以要移动指针，让top指针指向下一个元素，以确保栈顶元素成功出栈，最后返回temp即可得到栈顶元素。
此入栈出栈过程如下所示：

代码实现：

class Node(object):
    def __init__(self,data):
        self.next=None
        self.data=data
class Stack(object):
    def __init__(self):
        self.top=None            #删除插入都在一端 所以只定义一个位置

    def push(self,n):
        n=Node(n)                 #结构体创建，使其成为一个链表结构
        if(self.top==None):        #如果栈为空
            self.top=n
        else:
            n.next=self.top        #插入元素的next为栈顶元素
            self.top = n           #让插入值成为栈顶元素

    def pop(self):                 #出栈
        if(self.top==None):        #如果栈为空
            return None
        else:
            temp=self.top.data
            self.top=self.top.next #新的栈顶元素为老元素的上一个
            return temp

    def allquit(self):             #打印栈方法
        alist=[]
        while(self.top!=None):     #循环
            temp=self.top.data      #和pop()方法操作相同
            self.top=self.top.next
            alist.append(temp)
        print(alist)

if __name__== "__main__" :
    s=Stack()
    s.push(1)
    s.push(3)
    s.pop()
    s.allquit()
1234567891011121314151617181920212223242526272829303132333435363738

队列

和栈类似，队列也是常用的一种数据结构。其特征也很简单即“先进先出”那么什么是先进先出呢？顾名思义，像队列中插入一个元素，该元素成为该队列的队头，而后在插入元素则一次排列，最后一个元素称为该队列的队尾。在出队列的过程中，总是从队头开始向外出队，此过程即实现了“先进先出”我们可以看一个过程图，从而更清晰的了解该过程。

说到这里，相信大家对其原理已经很明确了。那么，难点又来了，如何在机器中实现该过程呢?
代码实现过程
1.类似于栈，在用链表进行表示时，首先要声明一个方法，为它开创一个节点。
2.定义last“指针” ，first”指针“。（为入队列出队列做准备）
3.入队列（该过程对队尾操作即与last有关）：首先要判断该队列是否为空，若为空则将last“指针”指向n，first“指针”也指向n（因为该队列只有一个元素，所以n即是first、也是last）；若不为空，则让last指针的指向域指向n，再将last指针移动到n。
4.出队列（该过程对队头操作即与first有关）：依旧是先判断其是否为空，若为空则返回None；若不为空，则首先定义一个temp变量让其=first的值，因为是出队列，所以要移动指针，让first指针指向下一个元素，以确保栈顶元素成功出栈，最后返回temp即可得到队头元素。

class Node(object):
    def __init__(self,val):  #节点传入值
        self.next=None       #每个节点定义2个属性 next指向下一个位置
        self.val=val         #                  val是节点的值

class Queue(object):
    def __init__(self):
        self.first=None      #每个队列定义2个属性 first删除端
        self.last=None       #                   last插入端

    def enqueue(self,n):
        n=Node(n)
        if(self.last==None): #如果队列为空
            self.first=n
            self.last=n
        else:                 #如果队列不为空
            self.last.next=n  #插入端的指向域指向n
            self.last=n       #插入端值为n

    def dequeue(self):
        if (self.first==None):
            return None
        else:
            reval=self.first.val
            self.first=self.first.next  #将删除端的第一个指定为下一个
            return reval
    def allquit(self):             # 打印
        alist=[]
        while (self.first!=None):       #循环
            temp=self.first.val         #和dequeue的操作相同
            self.first=self.first.next
            alist.append(temp)
        return alist

if __name__ == "__main__":
    q=Queue()
    q.enqueue(1)
    q.dequeue()
    print(q.allquit())