024.【链表算法】

1. 创建单向链表

例如，有“学生”这样一个链表，链表中需要包括学生的姓名、性别、学号等一些基本信息。创建这样的一个链表，链表里面包括多个学生的信息。

可以看出，“学生一”的尾结点“next”指向了下一个“学生二”的头结点学号“02”，这就是链表的特性，即上一个信息的尾结点next会指向下一个信息的头结点的内存地址。由于每个结点都包含了可以链接起来的地址信息，所以用一个变量就能够访问整个结点序列。

在上面讲解中出现了两个词：“指向”和“地址”，了解C语言的人可能会知道，这是典型的指针。没错，在C语言中，可以使用指针创建链表。但是在Python中并没有指针的概念，那么应该怎样创建链表呢？我们先来看如何使用Python交换两个值。首先是定义两个变量，代码如下：

x=13
y=14

利用Python交换两个变量代码如下：

x,y =y,x

在Python中交换值可以这样做，但在别的语言中不可以。这是因为在Python中，在定义x=13时，除了开辟一块内存给13这个值，还需要开辟一块内存用于存储13的地址，这块地址称之为x。类似地，在定义y=14时，除了开辟一块内存给14这个值，还需要开辟一块内存用于存储14的地址，这块称之为y。所以说，在Python中交换两个数的值，其实是地址的指向发生转换，类似于C语言中的指针。

在“x，y = y，x”中，我们先看右边，“y，x”的值分别为14，13。即得到“x，y =14，13”。然后x再存储14的地址，y再存储13的地址，这样就达到交换的效果。

因此，Python中的变量名保存的不是值，而是地址。同时，由于在Python中变量是隐式说明，所以Python中x可以指向任何东西。

了解地址在Python代码中的保存形式之后，就用Python代码实现利用结点创建一个链表的功能。代码如下：

"""
功能：定义类，作用是指向下一个结点。
"""

class Node():
    def __init__(self,elem):        	# 链表元素
        self.elem =elem
        self.next = None       			# 初始设置下一结点为空

创建学生链表，具体代码如下：

"""
功能：创建学生结点类
"""

class student:
    def __init__(self):
        self.name = ''
        self.sex = ''
        self.next = None

head=student()                                          	# 建立链表头部
head.next=None                                        		# 下一个元素为空
ptr=head                                            		# 储存指针的位置
select=0                                             		# 用来选择

while select!=2:                                         	# 不为2就循环
    print("(1)添加 (2)退出程序")                           	# 提示
    select = int(input('请输入一个选项：'))
    if select==1:                                       	# 选择1时，添加信息
        NewData=student()                             		# 添加下一个元素
        NewData.no = input("学号：")                     	# 添加学号
        NewData.name=input("姓名：")                 		# 添加姓名
        NewData.sex=input("性别：")                   		# 添加性别
        ptr.next=NewData                            		# 存储指针设置为新元素所在的位置
        NewData.next=None                        			# 下一个元素的next先设置为空
        ptr=ptr.next                                 		# 指向下一个结点
    elif select == 2:                                    	# 选择2时退出程序
       break
    else:                                          			# 选择其他时提示有误
        print("输入有误")

接下来创建一个链表类并初始化类，代码如下：

"""
功能：定义链表
"""

class LinkList():
    # 使用一个默认参数，传入头结点时则接收，没有传入时，则默认头结点为空
    def __init__(self, node=None ):
        self.__head = node       							# 表示私有属性，不对外开放

然后对这个链表进行基本的操作：

（1）在链表类中，定义一个方法is_empty()，它的功能是判断这个链表是否为空，代码如下：

"""
功能：判断链表是否为空
"""

# def is_empty(self):
    return self.__head == None

（2）在链表类中，定义一个方法LinkList_length()，它的功能是求链表的长度，代码如下：

"""
功能：求链表长度
"""

def LinkList_length(self):
    # cur游标，用来移动遍历结点
    cur = self.__head
    # count记录数量
    count = 0
    while cur != None:
        count += 1
        cur = cur.next
    return count

（3）在链表类中，定义一个方法LinkList_travel()，它的功能是遍历整个链表，代码如下：

"""
功能：遍历整个链表
"""

def LinkList_travel(self):
    cur = self.__head                  		# 指向头结点
    while cur != None:
        print(cur.elem, end=' ')            # 输出链表元素
        cur = cur.next                 		# 指向下一个结点
    print()

2. 单向链表结点的添加

单向链表结点添加分为头结点添加、尾结点添加以及在指定位置添加结点。

头结点变成了新添加学生的结点，然后新添加的学生next结点指向“学生一”的地址。用Python实现在头结点添加的功能，具体代码如下：

"""
功能：在头部添加新数据，item是数据
"""

def add(self, item):
    node = Node(item)            		# 添加新数据
    node.next = self.__head          	# 新数据的next指向原来的头结点
    self.__head = node             		# 新添加的数据变成头结点

当新添加学生的结点添加到“学生四”的结点后面，需要将链表最后的“学生四”的结点指向新添加学生的结点，接着将新添加学生的结点指向None。用Python实现在尾结点添加结点的功能，具体代码如下：

"""
功能：在尾部添加新数据，item是数据
"""

def append(self, item):
    # 这里的item是一个数据，不是结点
    node = Node(item)                  					# 新添加数据的结点
    # 由于特殊情况当链表为空时没有next，所以在前面要先做判断
    if self.is_empty():
        self.__head = node              				# 直接向把新添加信息给头结点
    else:                            					# 链表不为空
        cur = self.__head                				# 初始化cur游标
        while cur.next != None:            				# 判断游标指向空，就跳出循环
            cur = cur.next
        cur.next = node                					# 指向新添加数据的结点

可以看出，在“学生二”的结点和“学生三”的结点之间添加新学生的结点，需要将“学生二”的结点指向“新学生”的结点，然后将“新学生”的结点指向“学生三”的结点，这样就完成了在链表的中间位置添加结点的功能。

"""
功能：在中间位置添加新数据，item是数据
"""

def insert(self, pos, item):

    if pos <= 0:                               		# 如果pos位置在0或者以前，那么都当作头插法来做
        self.add(item)
    elif pos > self.LinkList_length()-1:            # 如果pos位置比原链表长，那么都当作尾插法来做
        self.append(item)
    else:                              				# 否则，采用中间位置添加
        node = Node(item)               			# 新数据的结点
        count = 0
        pre = self.__head
        while count<(pos-1):
            count += 1
            pre = pre.next
        # 当循环退出后，pre指向pos-1位置
        node.next = pre.next
        pre.next = node

3. 链表添加数据，具体代码如下：

"""
功能：定义结点类，作用是指向下一个结点
"""
class Node():
    def __init__(self, elem):
        self.elem = elem
        self.next = None

"""
功能：定义链表
"""
class LinkList(object):
    # 使用一个默认参数，传入头结点时则接收，没有传入时则默认头结点为空
    def __init__(self,node=None):
        self.__head = node   		# __表示私有属性，不对外开放

    """
    功能：判断链表是否为空
    """
    def is_empty(self):
      return self.__head == None


    """
    功能：求链表长度
    """
    def LinkList_length(self):
        # cur游标，用来移动遍历节点
        cur = self.__head
        # count记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    """
    功能：遍历整个链表
    """
    def LinkList_travel(self):
        cur = self.__head            		# 指向头结点
        while cur != None:
             print(cur.elem, end=' ') 		# 输出链表元素
             cur = cur.next          		# 指向下一个结点
        print()

    """
    功能：在头部添加新数据，item是数据
    """
    def add(self, item):
        node = Node(item)          			# 添加新数据
        node.next = self.__head      		# 新数据的next指向原来的头结点
        self.__head = node         			# 新添加的数据变成头结点

    """
    功能：在尾部添加新数据，item是数据
    """
    def append(self, item):
        # 这里的item是一个数据，不是节点
        node = Node(item)        			# 新添加数据的结点
        # 由于特殊情况当链表为空时没有next，所以在前面要先做判断
        if self.is_empty():
            self.__head = node    			# 直接把新添加信息给头结点
        else:                               # 链表不为空
            cur = self.__head       		# 初始化cur游标
            while cur.next != None: 		# 判断游标指向空，就跳出循环
                cur = cur.next
            cur.next = node        			# 指向新添加数据的结点

    """
    功能：在中间位置添加新数据，item是数据
    """
    def insert(self, pos, item):
        if pos <= 0:                		# 如果pos≤0，就调用“头部添加数据”函数
            self.add(item)
        # 如果pos位置比原链表长，就调用“尾部添加数据”函数
        elif pos > self.LinkList_length() - 1: 
            self.append(item)
        else:                   			# 否则，采用中间位置添加
            node = Node(item)    			# 新数据的结点
            count = 0
            pre = self.__head
            while count < (pos - 1):
                count += 1
                pre = pre.next
            # 当循环退出后，pre指向pos-1位置
            node.next = pre.next
            pre.next = node

 

LinkList_demo = LinkList()            		# 创建链表
LinkList_demo.add(25)              			# 调用add()函数在头结点添加数据
LinkList_demo.add(10)              			# 调用add()函数在头结点添加数据
LinkList_demo.append(39)            		# 调用append()函数在尾结点添加数据
LinkList_demo.insert(2, 49)             	# 调用insert()函数在第3个结点（结点下标从0开始）添加数据
LinkList_demo.insert(4, 54)            		# 调用insert()函数在第5个结点（结点下标从0开始）添加数据
LinkList_demo.insert(0, 60)             	# 调用insert()函数在第1个结点（结点下标从0开始）添加数据

# 调用LinkList_length()函数输出链表长度
print ("链表的长度是：",LinkList_demo.LinkList_length())
print("链表的各个数据分别是：")
LinkList_demo.LinkList_travel()        		# 调用LinkList_travel()函数输出链表各个数据

4. 单向链表结点的删除

可以看出，想删除“学生一”的结点，只要把链表中“学生一”这个头结点（head）指向“学生二”的结点，把“学生二”变成头结点（head）。

例如，“学生一”的结点是node，用Python算法实现，代码如下：

node=head         		# 要删除的结点是头结点
head = head.next      	# 现在是第二个结点变成头结点

可以看出，删除最后一个结点很简单，就是将链表的倒数第二个结点（即“学生三”的结点）指向none即可。例如倒数第二个结点为p，用Python算法实现，代码如下：

p.next=none               	# 原来p结点指向删除的none结点
p.next=None                	# 现在的p结点指向None

可以看出，如果要删除链表内的结点，只要将待删除结点的前一个结点p指向要删除结点的下一个结点即可。

例如，删除的结点为y，用Python算法实现代码如下：

y=p.next                      	# 删除结点
p.next=y.next                   # 上一个结点等于删除结点的下一个结点

链表删除数据，具体代码如下：

import sys

"""
功能：创建链表结点
"""
class student:
    def __init__(self):
        self.number=0                          	# 学生学号
        self.name=''                           	# 学生姓名
        self.sex = ''                         	# 学生性别
        self.next=None                          # 指向下一个结点

"""
功能：删除链表中的结点
"""
def del_ptr(head,ptr):
    top=head                                 	# 指向链表头结点
    if ptr.number==head.number:               	# 删除链表头结点
        head=head.next
        print('已删除学号 %d 同学 姓名：%s 性别:%s' %(ptr.number,ptr.name,ptr.sex))
    else:
        while top.next!=ptr:                 	# 找到删除结点的前一个位置
            top=top.next
        if ptr.next==None:                    	# 删除链表末尾的结点
            top.next=None
            print('已删除学号 %d 同学 姓名：%s 性别:%s' %(ptr.number,ptr.name,ptr.sex))
        else:
            top.next=ptr.next                   # 删除链表中的任意一个结点
            print('已删除学号 %d 同学 姓名：%s 性别:%s' %(ptr.number,ptr.name,ptr.sex))
    return head                             	# 返回链表

findword=0
name_data=['Luck','Talon','Mark','Bill']      		# 学生姓名
data=[[1,"Woman"],[2,"Man"],[3,"Man"],[4,"Man"]]  	# 学生学号、性别
print('学号 性别 ')
print('-----------')

for i in range(4):                            		# 遍历输出链表数据
    for j in range(1):
        print('%2d   %3s  ' %(data[j+i][0],data[j*2+i][1]),end='')
    print()
head=student()                              		# 建立链表头部

if not head:
    print('Error!! 内存分配失败!!')
    sys.exit(0)

head.number=data[0][0]                         		# 初始化头结点学号
head.name=name_data[0]                       		# 初始化头结点姓名
head.sex=data[0][1]                           		# 初始化头结点性别
head.next=None
ptr=head

for i in range(1,4):                            	# 建立链表
    new_node=student()
    new_node.number=data[i][0]
    new_node.name=name_data[i]
    new_node.sex=data[i][1]
    new_node.number=data[i][0]
    new_node.next=None
    ptr.next=new_node
    ptr=ptr.next

        

while(True):
    findword=int(input('请输入要删除的学号，输入0表示结束删除过程，请输入：'))
    if(findword==0):                              	# 循环中断条件，输入0程序结束
        break	
    else:                                       	# 否则，根据学号删除学生
        ptr=head
        find=0
        while ptr!=None:
            if ptr.number==findword:                # 判断学号是否在链表中，是则删除
                ptr=del_ptr(head,ptr)               # 调用删除函数
                find=find+1
                head=ptr
            ptr=ptr.next
        if find==0:
            print('没有找到')
      
ptr=head
print('\t学号    姓名\t性别')                      	# 打印剩余链表中的数据
print('\t----------------------------')

while(ptr!=None):
    print('\t%2d\t    %-5s\t%3s' %(ptr.number,ptr.name,ptr.sex))
    ptr=ptr.next
print('\t----------------------------')

5. 单向链表的连接

可以看出，链表的连接是将head1链表的最后一个结点连接到head2指向的链表的头结点，这样就可以完成链表的连接。

例如，p是连接两个链表之后的大链表指针，用Python代码实现连接的算法如下：

p=head1                          		# 指向头结点为head1的链表
while p.next!=None:                  	# p.next直到为None时，表示head1到尾结点，跳出循环
    p=p.next                    		# 循环指向head1链表的结点
    p.next=head2                		# 将head1的尾结点链接到head2的头结点上

连接两个职员链表，具体代码如下：

import sys
import random

"""
功能：将两个职员链表连接
参数：head1:职员1链表头结点
     head2:职员1链表头结点
"""
def connect_list(head1, head2):
    p = head1                                		# 指向头结点为head1的链表
    while p.next != None:                         	# p.next直到为None时，表示head1到了尾结点，跳出循环
        p = p.next                             		# 循环指向head1链表的结点
    p.next = head2                             		# 将head1的尾结点链接到head2的头结点上
    return head1

class employee:                                		# 创建职员结点
    def __init__(self):
        self.num = 0                           		# 职员工位号
        self.salary = 0                         	# 职员薪资
        self.name = ''                          	# 职员姓名
        self.next = None                        	# 指向下一个结点

findword = 0
data = [[None] * 2 for row in range(4)]            	# 列表推导式
employee_data1 = ['张三', '李四', '王五', '刘六'] 		# 链表1职员姓名
employee_data2 = ['狗剩', '二狗', '铁蛋', '钢镚'] 		# 链表2职员姓名

for i in range(4):                          		# 遍历职员
    data[i][0] = i + 1
    data[i][1] = random.randint(5000, 10000)    	# 随机在(5000, 10000)之间生成薪资

head1 = employee()                            		# 建立第一组链表的头部
if not head1:
    print('Error!! 内存分配失败!!')
    sys.exit(0)

head1.num = data[0][0]                         		# 职员1链表头部工位号
head1.name = employee_data1[0]                  	# 职员1链表头部姓名
head1.salary = data[0][1]                        	# 职员1链表头部薪资
head1.next = None                           		# 指向尾结点
p = head1
for i in range(1, 4):                             	# 建立第一组链表
    new_node = employee()
    new_node.num = data[i][0]                  		# 职员1链表工位号
    new_node.name = employee_data1[i]        		# 职员1链表姓名
    new_node.salary = data[i][1]                  	# 职员1链表薪资
    new_node.next = None
    p.next = new_node
    p = p.next
for i in range(4):
    data[i][0] = i + 5
    data[i][1] = random.randint(5100, 10000)

head2 = employee()                                 	# 建立第二组链表的头部（和第一组链表一样）
if not head2:
    print('Error!! 内存分配失败!!')
    sys.exit(0)

head2.num = data[0][0]
head2.name = employee_data2[0]
head2.salary = data[0][1]
head2.next = None
p = head2
for i in range(1, 4):                           	# 建立第二组链表
    new_node = employee()
    new_node.num = data[i][0]
    new_node.name = employee_data2[i]
    new_node.salary = data[i][1]
    new_node.next = None
    p.next = new_node
    p = p.next

i = 0
p = connect_list(head1, head2)                		# 调用connect_list()函数将链表相连
print('两个链表相连的结果为：')
while p != None:                                  	# 打印链表的数据
    print("◆",p.num," " *3,p.name," "*3,p.salary,"◇" )
    print()
    p = p.next

6. 单向链表的反转

了解单向链表的添加和删除操作之后，发现在链表结构中添加结点和删除结点都比较容易，从头到尾输出链表也不是什么难事。这是因为我们知道单向链表中的每个结点都会指向下一个结点，知道了一个结点的位置，整个链表的每个结点就都知道了。但是如果想反转过来输出链表，知道一个链表的位置，却不能知道此结点的上一个结点位置，该如何入手呢？

在Python算法中，实现单向链表反转的具体代码如下：

"""
功能：链表反转
参数：head是链表的头结点
"""
def reverse(head):
    p= head               	# 定义变量p指向head
    q=None              	# q是p的前一个结点

    while p!=None:
        a=q             	# 将a接到q之后
        q=p              	# 将q接到p之后
        p=p.next          	# p移到下一个结点
        q.next=a           	# q连接到之前的结点
    return q

从代码中可以看到，实现单向链表反转需要用到三个变量：p、q、a，接下来我们来看这一段程序的反转过程。

步骤1：执行while语句前，变量p指向了头结点，变量q为空，此时链表的情况如图所示。

步骤2：执行第一次while循环，借助变量a，将变量a接到变量q之后,将变量q接到变量p之后，变量p结点向下一个结点移动，再将变量q连接到之前的结点，此时链表的情况如图所示。

步骤3：执行第二次while循环，这次将变量q的位置交接给变量a，变量p的位置交接给变量q，变量p再向下一个节点移动，最后将变量q的结点连接到之前的结点变量a上，此时链表的情况如图所示。

步骤4：执行第三次循环，再次将变量q交接给变量a，变量p交接给变量q，变量p再向下一个结点移动，然后变量q连接到之前的结点变量a上，此时链表的情况如图所示。

直到p=None时，整个单向链表就反转过来了，最终链表反转如图25所示。

反转学生链表，具体代码如下：

import sys

"""
功能：创建链表结点
"""
class student:
    def __init__(self):
        self.number=0                                			# 学生的学号
        self.name=''                                  			# 学生的姓名
        self.sex = ''                                   		# 学生的性别
        self.next=''

findword=0
name_data=['Luck','Talon','Mark','Bill']                        # 链表学生名字
data=[[1,"Woman"],[2,"Man"],[3,"Man"],[4,"Man"]]              	# 链表学生学号和性别
head=student()                                              	# 建立链表头部
if not head:
    print('Error!! 内存分配失败!!')
    sys.exit(0)

head.number=data[0][0]                                       	# 链表头部学生学号
head.name=name_data[0]                                      	# 链表头部学生姓名
head.sex=data[0][1]                                          	# 链表头部学生性别
head.next=None
ptr=head
for i in range(1,4):                                         	# 建立链表
    new_node=student()
    new_node.number=data[i][0]                             		# 初始化链表学生学号
    new_node.name=name_data[i]                              	# 初始化链表学生姓名
    new_node.sex=data[i][1]                               		# 初始化链表学生性别
    new_node.next=None
    ptr.next=new_node                                   		# 指向学生链表下一个结点
    ptr=ptr.next

ptr=head
i=0
print('反转前的学生链表结点数据：')
while ptr !=None:                                       		# 打印链表数据
    print('☆ %2d\t  %-1s\t%-3s  ☆' %(ptr.number,ptr.name,ptr.sex), end='')
    i=i+1
    if i>=1:                                           			# 一个数据为一行
        print()
        i=0
    ptr=ptr.next                                        		# 指向下一个结点

ptr=head
before=None  
print('\n反转后的学生链表结点数据：')
while ptr!=None:                                        		# 链表反转，利用三个指针，反转指针核心
    last=before
    before=ptr
    ptr=ptr.next
    before.next=last

ptr=before
while ptr!=None:                                        		# 打印链表数据
    print('★ %2d\t  %-1s\t%-3s   ★' %(ptr.number,ptr.name,ptr.sex), end='')
    i=i+1
    if i>=1:                                         			# 一个数据为一行
        print()
        i=0
    ptr=ptr.next

7. 堆栈、队列与链表

堆栈与队列都是比较抽象的数据结构，它们在计算机领域的应用都很广。堆栈多用于递归调用。堆栈简单来说就是将数据一层一层堆积起来，要想获取数据，需要先将后堆的数据取出，堆栈的数据结构是典型的“后进先出”结构。生活中也有很多类似堆栈的例子，例如装卸货车，把商品一层一层堆在货车上，卸货车时，需要从最后堆的上面一层开始卸。

而队列不同，队列就像排队一样，刚来的人入队时要排在队尾，每次出队的都是队首的人，它的数据结构是典型的“先进先出”。

7.1 用链表实现堆栈

使用链表实现堆栈的优点是可以随时动态改变链表的长度，能有效地利用内存空间，保证不浪费内存，实现用多大就申请多大的内存空间的功能。但这种功能有利也有弊，它的缺点就是设计的算法有点复杂。但是理解了堆栈的本质，该算法也不难理解，接下来我们来看用Python链表算法如何实现堆栈。

（1）声明堆栈的链表结点

"""
功能：定义堆栈链表结点类
"""
class Node:
    def __init__(self):
        self.data=0            	# 声明堆栈数据
        self.next=None         	# 堆栈用来指向下一个结点

top=None                      	# 声明顶端并初始化

（2）判断堆栈链表是否为空

"""
功能：判断堆栈链表是否为空
"""
def is_empty():
    global top               	# 将top声明为全局变量
    if(top==None):           	# 顶端为None
        return 1            	# 返回1
    else:                  		# 否则
        return 0            	# 返回0

（3）将数据压入堆栈

"""

功能：将数据压入堆栈中

"""

def push(data):
    global top
    new_node=Node()           		# 新结点
    new_node.data=data           	# 将数据指定为结点的内容
    new_node.next=top           	# 将新结点指向堆栈的顶端
    top=new_node              		# 新结点成为堆栈的顶端

（4）将数据弹出堆栈（从堆栈中取数据）

"""
功能：将数据弹出
"""
def pop():
    global top
    if is_empty():                      	# 判断堆栈链表是否为空
        print("当前堆栈链表为空")
        return -1                      		# 退出程序
    else:
        p=top                       		# 指向堆栈的顶端
        top=top.next                   		# 将堆栈顶端指向下一个结点
        temp=p.data                   		# 弹出数据
        return temp                     	# 将从堆栈中弹出的数据返回给主程序

使用链表实现堆栈

"""

功能：定义堆栈链表结点类

"""

class Node:

	def __init__(self):
        self.data=0                  	# 声明堆栈数据
        self.next=None              	# 堆栈来指向下一个结点
	top=None                         	# 声明顶端并初始化

"""
功能：判断堆栈链表是否为空
"""
def is_empty():
    global top                       	# 将top声明为全局变量
    if(top==None):                   	# 顶端为None
        return 1                     	# 返回1
    else:                          		# 否则
        return 0                     	# 返回0

"""
功能：将数据压入堆栈中
"""
def push(data):
    global top
    new_node=Node()                 	# 新结点
    new_node.data=data                	# 将数据指定为结点的内容
    new_node.next=top                 	# 将新结点指向堆栈的顶端
    top=new_node                    	# 新结点成为堆栈的顶端

"""
功能：将数据弹出
"""
def pop():
    global top
    if is_empty():                 		# 判断堆栈链表为空
        print("当前堆栈链表为空")
        return -1                 		# 退出程序
    else:
        p=top                   		# 指向堆栈的顶端
        top=top.next               		# 将堆栈顶端指向下一个结点
        temp=p.data              		# 弹出数据
        return temp               		# 将从堆栈中弹出的数据返回给主程序

while True:
    i=int(input("1:向堆栈中压入数据,2;堆栈中弹出,3:退出堆栈操作：请输入您的选择: "))
    if i==1:
        data = int(input("请输入要压入的数据:"))
        push(data)                 		# 调用堆栈压入数据函数
    elif i==2:
        print("弹出的数据为", pop()) 		# 调用堆栈弹出数据函数
    elif i==3:
        break                   		# 退出堆栈操作，即退出循环

print("---------------------------------------")
while(not is_empty()):              	# 将数据陆续从顶端弹出
    print('堆栈弹出的顺序为:%d' %pop())

print("---------------------------------------")
print("可以看出：先压入的数据后弹出，后压入的数据先弹出")

可以看出压入数据和弹出数据的情况。

7.2 用链表实现队列

队列也可以用链表实现，在定义队列方法时，要包含指向队列前端和队列末端的指针。接下来我们来看用Python链表算法如何实现队列。

我们用职员的姓名和工号来建立队列。

（1）建立职员队列链表结点

"""
功能：定义职员队列链表
"""
class worker:
    def __init__(self):
        self.name=''*20 	# 职员名字
        self.number=0  		# 职员工位号
        self.next=None 		# 队列中指向下一个结点

fore=worker()
end=worker()
fore=None            		# 队列前端指针
end=None                   	# 队列末尾指针

（2）将数据加入队列中

"""
功能：将数据加入到队列中
参数：name：表示职员名字
      number:表示职员工位号
"""
def add_queue(name,number):
    global fore
    global end
    new_data=worker()               	# 分配内存给新数据
    new_data.name=name              	# 为新数据赋值
    new_data.number=number          	# 为新数据赋值
    if end==None:                    	# 如果end为None，表示这是第一个元素
        fore=new_data
    else:
        end.next=new_data             	# 将新数据连接到队列末尾
    end=new_data                   		# 将end指向新数据，这是新数据的末尾
    new_data.next=None                	# 新数据之后再无其他数据

（3）取出队列中的数据

"""
功能：取出队列中的数据
"""
def out_queue():
    global fore
    global end
    if fore==None:                     						# 如果队列前端为None，表示这个队列为空
        print("队列已经没有数据了")
    else:#否则
        print("姓名：",fore.name," 工号：",fore.number)  		# 输出信息
        fore=fore.next             							# 将队列前端移到下一个元素

使用链表实现职员队列

"""
功能：定义职员队列链表
"""
class worker:
    def __init__(self):
        self.name=''*20                             	# 职员名字
        self.number=0                              		# 职员工位号
        self.next=None                             		# 队列中指向下一个结点
fore=worker()
end=worker()
fore=None                                       		# 队列前端指针
end=None                                       			# 队列末尾指针

"""
功能：将数据加入到队列中
参数：name：表示职员名字
      number:表示职员工位号
"""
def add_queue(name,number):
    global fore
    global end
    new_data=worker()                                 	# 分配内存给新数据
    new_data.name=name                                 	# 为新数据赋值
    new_data.number=number                          	# 为新数据赋值
    if end==None:                                       # 如果end为None，表示这是第一个元素
        fore=new_data
    else:
        end.next=new_data                         		# 将新数据连接到队列末尾
    end=new_data                                        # 将end指向新数据，这是新数据的末尾
    new_data.next=None                           		# 新数据之后再无其他数据

"""
功能：取出队列中的数据
"""
def out_queue():
    global fore
    global end
    if fore==None:                               		# 如果队列前端为None，表示这个队列为空
        print("队列已经没有数据了")
    else:  	# 否则
        print("姓名：",fore.name," 工号：",fore.number)  	# 输出信息
         	# 将队列前端移到下一个元素
        fore=fore.next                           

"""
功能：显示队列中的数据
"""
def show():
    global fore
    global end
    p = fore                                    		# 从队列前端开始
    if p== None:                                		# 判断p为空，则队列为空
        print('队列已空！')                        		# 提示
    else:
        while p != None:                         		# 从队列前端(fore)到队列末尾(end)遍历队列
            print("姓名：",p.name,"\t工号:", p.number)  	# 输出队列信息
            p = p.next                          		# 指向下一个结点

i = 0                                          			# 用于选择变量
while True:
    i = int(input("1:向队列加入数据 2:从队列中取出数据 3:显示队列中数据 4:退出程序,请选择："))
    if i == 1:                                    		# 选择1
        name = input("姓名: ")                      		# 输出职员姓名
        score = int(input("工位号: "))                   # 输入职员工位号
        add_queue(name, score)                    		# 向队列中加入数据
    elif i == 2:                                   		# 选择2
        out_queue()                             		# 在队列中取出数据
    elif i==3:                                   		# 选择3
        show()                               			# 显示在队列中未取出的数据
    elif i == 4:                                   		# 选择4
            break                            			# 退出程序
    else:                                     			# 否则
        print("输入有误")                         		# 提示输入有误

可以看出在队列中加入数据和取出数据的情况。