数据结构--栈/队列/链表

1. 栈

栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。

栈有顺序栈和链栈之分，在顺序栈中，定义了栈的栈底指针（存储空间首地址base）、栈顶指针top以及顺序存储空间的大小stacksize。

其实这二者的区别是由顺序表和链表的存储结构决定的，在空间上，顺序表是静态分配的，而链表则是动态分配的；就存储密度来说：顺序表等于1，而链式表小于1，但是链式表可以将很多零碎的空间利用起来；顺序表查找方便，链式表插入和删除时很方便。 顺序表的这种静态存储的方式，决定了必须至少得有首地址和末地址来决定一个空间，否则，不知道查找到哪了；链式表每个节点存储了下一个节点的指针信息，故，对于链栈来说，只需要一个top指针即可查找到整个栈

参考链接来自：
https://blog.csdn.net/xlengji/article/details/82143396
https://blog.csdn.net/handsomewangjg/article/details/47961189

1.1 顺序栈

class SequenceStack:
    def __init__(self):
        self.MaxStackSize = 10
        self.s = [None for x in range(0,self.MaxStackSize)]
        self.top = -1
        
    '''判断栈是否为空'''
    def IsEmptyStack(self):
        if self.top == -1:
            iTop = True
        else:
            iTop = False
        return iTop
    '''进栈'''
    def PushStack(self,x):
        if self.top < self.MaxStackSize-1:
            self.top = self.top+1
            self.s[self.top] = x
        else:
            print("栈满")
            return
    '''出栈'''
    def PopStack(self):
        if self.IsEmptyStack == True:
            print("栈为空")
            return
        else:
            iTop = self.top
            self.top = self.top-1
            return self.s[iTop]
    '''获取栈顶元素'''
    def GetTopStack(self):
        if self.IsEmptyStack == True:
            return "栈为空"
        else:
            return self.s[self.top]
    '''遍历栈内元素'''
    def StackTraverse(self):
        if self.IsEmptyStack == True:
            return "栈为空"
        else:
            for i in range(0,self.top + 1):
                print(self.s[i],end = ' ')
    '''创建一个顺序栈'''
    def CreateStackByInput(self):
        data = input("请输入元素（确定按回车键，结束按“#”）：")
        while data != "#":
            self.PushStack(data)
            data = input("请输入元素（确定按回车键，结束按“#”）：")
    '''获取顺序栈的长度'''
    def GetStackLength(self):
        num = 0
        for i in range(0,self.top + 1):
            num = num+1
        return num
# In[]
if __name__ == '__main__':
    ss = SequenceStack()
    ss.CreateStackByInput()
    print("栈内元素为：",end = " ")
    ss.StackTraverse()
    print("\n栈顶元素为：",ss.GetTopStack())
    print("顺序栈的长度为：",ss.GetStackLength())

原代码来自以下链接：

https://blog.csdn.net/weixin_40283816/article/details/87890661

1.2 链式栈

1.3 编程模拟实现一个浏览器的前进、后退功能

待完善

2. 队列

2.1 顺序队列

2.2 链式队列

2.3 实现一个循环队列

3. 链表

3.1 单链表、循环链表、双向链表

class SingleNode:
    def __init__(self,item):
        self.item=item
        self.next=None
        
class SingleLinkList:
    def __init__(self):
        self.head=None
    def IsEmpty(self):
        return self.head is None
    def Length(self):
        p=self.head
        count=0
        while p is not None:
            count+=1
            p=p.next
        return count
    def travelLink(self):
        p=self.head
        while p is not None:
            print(p.item)
            p=p.next
        print("\n")
    def CreatLink(self):
        item=input("请输入元素（确定按回车键，结束按“#”）：")
        self.head=SingleNode(item)
        p=self.head
        while item !="#":
            p.next=SingleNode(item)
            p=p.next          
            item = input("请输入元素（确定按回车键，结束按“#”）：")       
# In[]        
if __name__ == '__main__': 
    link=SingleLinkList()
    link.CreatLink()
    count=link.Length()

https://www.cnblogs.com/reader/p/9547621.html

3.2 实现链表反转

3.3 实现两个有序链表合并为一个有序链表

3.4 实现求链表的中间结点

参考链接

https://www.cnblogs.com/reader/p/9547621.html