数据结构与算法--（链表，栈，队列）

最新推荐文章于 2023-11-24 22:32:09 发布
最新推荐文章于 2023-11-24 22:32:09 发布
阅读量621 收藏 8
点赞数 8
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43710889/article/details/115972111
版权

数据结构与算法–（链表，栈，队列）

文章目录

链表

定义

链表：是一种常见的数据结构，是一种线性表。不像顺序表那样连续存储数据，而是在每个节点（数据存储单元）里存放下一个节点的位置信息（地址）。

单向链表

单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域(元素域)和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。

功能:

1.头部添加元素
    def add(self,item):
        node = Node(item)
        # 将新节点的链接域next指向头结点
        node.next=self.__head
        #将链表头__head指向新节点
        self.__head = node
2.尾部添加元素
    #尾部追加
    def append(self,item):
        node = Node(item)
        curNode = self.__head
        #链表为空和不为空的情况
        if self.is_empty():
            self.__head = node
        else:
            while curNode.next !=None:
                curNode = curNode.next
            curNode.next = node
3.指定位置添加元素
    #指定位置添加
    def insert(self,post,item):
        #如果post插入位置小于等于0，属于头部插入
        if (post-1)<=0:
            self.add(item)
        # 如果post插入位置大于等于链表长度，属于尾部插入
        elif post>=self.length():
            self.append(item)
        #正常插入
        else:
            count = 0
            preNode = self.__head
            node = Node(item)
            while count<(post-1):
                count += 1
                preNode = preNode.next

            node.next=preNode.next
            preNode.next = node
4.删除节点
	#删除节点
    def remove(self,item):

        curNode = self.__head
        preNode = None
        while curNode!=None:
            #判断是否为头结点
            if curNode.elem == item:
                if preNode == None:
                    self.__head = curNode.next
                else:
                    preNode.next = curNode.next
                break
            else:
                preNode = curNode
                curNode = curNode.next
5.查找节点是否存在
    #查找节点是否存在
    def search(self,item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem==item:
                return True
            curNode = curNode.next
        return False
6.判断链表是否为空
    #判断当前链表是否为空
    def is_empty(self):
        return self.__head == None
7.当前链表的长度
    #当前链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count
8.遍历链表
    #遍历
    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem,end='\t')
            curNode = curNode.next
全部代码粘贴

class Node(object):
    def __init__(self,elem):
        #elem：数据元素
        self.elem=elem
        #next：下一个节点的链接域
        self.next=None

#构建单向链表类
class SingleLinkList:
    #初始化方法
    def __init__(self,node=None):
        if node!=None:
            headNode = Node(node)
            self.__head=headNode
        else:
            self.__head=node
        # print(self.__head)


    #在头部添加元素
    def add(self,item):
        node = Node(item)
        # 将新节点的链接域next指向头结点
        node.next=self.__head
        #将链表头__head指向新节点
        self.__head = node

    #尾部追加
    def append(self,item):
        node = Node(item)
        curNode = self.__head
        #链表为空和不为空的情况
        if self.is_empty():
            self.__head = node
        else:
            while curNode.next !=None:
                curNode = curNode.next
            curNode.next = node

    #指定位置添加
    def insert(self,post,item):
        #如果post插入位置小于等于0，属于头部插入
        if (post-1)<=0:
            self.add(item)
        # 如果post插入位置大于等于链表长度，属于尾部插入
        elif post>=self.length():
            self.append(item)
        #正常插入
        else:
            count = 0
            preNode = self.__head
            node = Node(item)
            while count<(post-1):
                count += 1
                preNode = preNode.next

            node.next=preNode.next
            preNode.next = node
    #删除节点
    def remove(self,item):

        curNode = self.__head
        preNode = None
        while curNode!=None:
            #判断是否为头结点
            if curNode.elem == item:
                if preNode == None:
                    self.__head = curNode.next
                else:
                    preNode.next = curNode.next
                break
            else:
                preNode = curNode
                curNode = curNode.next

    #查找节点是否存在
    def search(self,item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem==item:
                return True
            curNode = curNode.next
        return False

    #判断当前链表是否为空
    def is_empty(self):
        return self.__head == None

    #当前链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count

    #遍历
    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem,end='\t')
            curNode = curNode.next

if __name__ == '__main__':
    singleLinkList=SingleLinkList()
    # print('链表长度：',singleLinkList.length())
    # print('链表是否为空:',singleLinkList.is_empty())
    # print('遍历链表:', end=' ')
    # singleLinkList.travel()
    # print('查找节点是否存在:', singleLinkList.search(20))
    # singleLinkList.add(1)
    # singleLinkList.add(2)
    # singleLinkList.add(3)
    singleLinkList.append(1)
    singleLinkList.append(2)
    singleLinkList.append(3)
    singleLinkList.insert(10,4)
    singleLinkList.remove(4)
    singleLinkList.remove(1)
    print('遍历链表:', end=' ')
    singleLinkList.travel()

循环链表

在链表中，使链表的尾部节点的‘next’指针指向链表的头部。

在这里插入图片描述

轮转调度：在这个调度程序中，以循环的方式迭代的遍历一个元素的集合，通过执行一个给定的动作为集合中的每个元素进行服务。

在这里插入图片描述

循环链表实现队列

class CircularQueue:
    class _Node:
        '''Lightweight,nonpublic class for storing a singly linked node.'''
        __slots__ = '_element','_next'

        def __init__(self,element,next):
            self._element = element
            self._next = next

    def __init__(self):
        '''create an empty queue'''
        self._tail = None
        self._size = 0

    # queque length
    def __len__(self):
        return self._size

    # queue is empty?
    def is_empty(self):
        '''return true if the queue is empty'''
        return self._size == 0
    def first(self):
        '''return(but not remove) the element at the front of the queue'''
        if self.is_empty():
            raise TypeError("Queue is Empty!")
        head = self._tail._next
        return head._element



    def dequeue(self):
        '''remove and return the first element of thr queue'''
        if self.is_empty():
            raise TypeError('the Queue is empty!')
        oldhead = self._tail._next
        if self._size == 1:
            self._tail._next = None
        else:
            self._tail._next = oldhead._next
        return oldhead._element

    def enqueue(self,item):
        '''add an element to the back of queue'''
        newest = self._Node(item,None)
        if self.is_empty():
            newest._next = newest
        else:
            newest._next = self._tail._next
            self._tail._next = newest
        self._tail = newest
        self._size += 1

    def rotate(self):
        '''rotate front element to the back of the queue'''
        if self._size >0:
            self._tail = self._tail._next

    def travel(self):
        head = self._tail._next
        print(head._element,end=' ')
        head = head._next
        while head is not self._tail._next:
            print(head._element,end=' ')
            head = head._next
        print('')
if __name__ == '__main__':
    circularQueue = CircularQueue()
    circularQueue.enqueue(1)
    circularQueue.enqueue(2)
    circularQueue.enqueue(2)
    circularQueue.travel()
    print(circularQueue.dequeue())
    circularQueue.travel()

双向链表

每个节点有两个链接：一个指向前一个节点（当此节点为第一个节点时，指向空值）；另一个节点指向下一个节点（当此节点为最后一个节点时，指向空值）

功能:

1.头部添加元素
    #在头部添加元素
    def add(self,item):
        node = Node(item)
        #判断是否是空列表
        if self.is_empty():
            self.__head = node
        else:
            # 将新节点的链接域next指向头结点
            node.next=self.__head

            #将__head 的头节点的prev指向node
            self.__head.prev = node

            #将链表头__head指向新节点
            self.__head = node
2.尾部添加元素
    #尾部追加
    def append(self,item):
        node = Node(item)
        curNode = self.__head
        #链表为空和不为空的情况
        if self.is_empty():
            self.__head = node

        else:
            while curNode.next !=None:
                curNode = curNode.next
            curNode.next = node
            #将node节点的前驱指向当前节点
            node.prev = curNode
3.指定位置添加元素
    #指定位置添加
    def insert(self,post,item):
        #如果post插入位置小于等于0，属于头部插入
        if (post-1)<=0:
            self.add(item)
        # 如果post插入位置大于等于链表长度，属于尾部插入
        elif post>=self.length():
            self.append(item)
        #正常插入
        else:
            count = 0
            preNode = self.__head
            node = Node(item)
            while count<(post-1):
                count += 1
                preNode = preNode.next

            node.next=preNode.next
            node.prev = preNode
            preNode.next.prev = node
            preNode.next = node
4.删除节点
	 #删除节点
    def remove(self,item):

        curNode = self.__head
        while curNode!=None:
            #判断是否为头结点
            if curNode.elem == item:
                if curNode == self.__head:
                    self.__head = curNode.next
                    #判断当前节点是否只有一个节点
                    if curNode.next:
                        curNode.next.prev = None

                else:
                    curNode.prev.next = curNode.next
                    if curNode.next:
                        curNode.next.prev = curNode.prev
                break
            else:
                curNode = curNode.next
5.查找节点是否存在
    #查找节点是否存在
    def search(self,item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem==item:
                return True
            curNode = curNode.next
        return False
6.判断链表是否为空
    #判断当前链表是否为空
    def is_empty(self):
        return self.__head == None
7.当前链表的长度
    #当前链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count
8.遍历链表
    #遍历
    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem,end='\t')
            curNode = curNode.next
全部代码粘贴
class Node(object):
    def __init__(self,elem):
        self.elem = elem
        self.prev = None
        self.next = None


#构建双向链表类
class DoubleLinkList:
    #初始化方法
    def __init__(self,node=None):
        if node!=None:
            headNode = Node(node)
            self.__head=headNode
        else:
            self.__head=node
        # print(self.__head)


    #在头部添加元素
    def add(self,item):
        node = Node(item)
        #判断是否是空列表
        if self.is_empty():
            self.__head = node
        else:
            # 将新节点的链接域next指向头结点
            node.next=self.__head

            #将__head 的头节点的prev指向node
            self.__head.prev = node

            #将链表头__head指向新节点
            self.__head = node

    #尾部追加
    def append(self,item):
        node = Node(item)
        curNode = self.__head
        #链表为空和不为空的情况
        if self.is_empty():
            self.__head = node

        else:
            while curNode.next !=None:
                curNode = curNode.next
            curNode.next = node
            #将node节点的前驱指向当前节点
            node.prev = curNode

    #指定位置添加
    def insert(self,post,item):
        #如果post插入位置小于等于0，属于头部插入
        if (post-1)<=0:
            self.add(item)
        # 如果post插入位置大于等于链表长度，属于尾部插入
        elif post>=self.length():
            self.append(item)
        #正常插入
        else:
            count = 0
            preNode = self.__head
            node = Node(item)
            while count<(post-1):
                count += 1
                preNode = preNode.next

            node.next=preNode.next
            node.prev = preNode
            preNode.next.prev = node
            preNode.next = node
    #删除节点
    def remove(self,item):

        curNode = self.__head
        while curNode!=None:
            #判断是否为头结点
            if curNode.elem == item:
                if curNode == self.__head:
                    self.__head = curNode.next
                    #判断当前节点是否只有一个节点
                    if curNode.next:
                        curNode.next.prev = None

                else:
                    curNode.prev.next = curNode.next
                    if curNode.next:
                        curNode.next.prev = curNode.prev
                break
            else:
                curNode = curNode.next

    #查找节点是否存在
    def search(self,item):
        curNode = self.__head
        while curNode != None:
            if curNode.elem==item:
                return True
            curNode = curNode.next
        return False

    #判断当前链表是否为空
    def is_empty(self):
        return self.__head == None

    #当前链表的长度
    def length(self):
        count = 0
        curNode = self.__head
        while curNode != None:
            count += 1
            curNode = curNode.next
        return count

    #遍历
    def travel(self):
        curNode = self.__head
        while curNode != None:
            print(curNode.elem,end='\t')
            curNode = curNode.next

if __name__ == '__main__':
    doubleLinkList = DoubleLinkList()
    doubleLinkList.add(1)
    doubleLinkList.add(12)
    doubleLinkList.append(21)
    doubleLinkList.append(22)
    doubleLinkList.insert(2,2)
    doubleLinkList.remove(23)
    doubleLinkList.travel()

栈（stack）

是一种容器，可以存入数据，访问元素，删除元素，（LIFO）

特点：只允许在容器的一端加入元素和输出元素，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素。

栈的实现

class Stack(object):
    def __init__(self):
        self.__list = []

    #压栈
    def push(self,item):
        self.__list.append(item)

    #弹出元素
    def pop(self):
        return self.__list.pop()

    #返回栈顶元素
    def peek(self):

        return self.__list[len(self.__list)-1]

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

    #计算栈的大小

    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    stack = Stack()
    #压栈
    stack.push(1)
    stack.push(2)
    stack.push(3)
    stack.push(4)
    #弹出
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())
    print(stack.pop())

队列（queue）

只允许在一端进行插入操作，另一端进行删除操作的线性表。（FIFO）。允许插入的一端为队尾，允许删除的一端为对头。

队列的实现

class Queue(object):
    def __init__(self):
        self.__list = []

    #进队
    def enqueue(self,item):
        self.__list.append(item)
        # self.__list.insert(0,item)

    #出队
    def dequeue(self):
        return self.__list.pop(0)
        # return self.__list.pop()
    #判断队列是否为空
    def is_empty(self):
        return self.__list == []

    #计算队列的大小
    def size(self):
        return len(self.__list)

if __name__ == '__main__':
    queue = Queue()
    queue.enqueue(1)
    queue.enqueue(2)
    queue.enqueue(3)
    print(queue.size())
    print(queue.dequeue())
    print(queue.size())
    print(queue.is_empty())
南岸青栀*
关注
  • 8
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
数据结构与算法-实验3 栈和队列
11-19
本实验主要涉及两种常用的数据结构——栈（Stack）和队列（Queue），并要求通过实验实现这两种数据结构的不同版本：顺序栈、链栈、循环队列和链队列。 **栈**是一种后进先出（LIFO, Last In First Out）的数据结构...
Python数据结构与算法-数据结构(列表、栈、队列、链表)
little_limin的博客
04-04 3658
python的数据结构与算法
数据结构与算法《一》数组、链表、栈、队列
07-14 476
桶排序 原理：桶排序（Bucket Sort）顾名思义，会用到“桶”，桶我们可以将其想象成一个容器，核心思想是将要排序的数据分到几个有序的桶里，每个桶里的数据再单独进行排序。桶内排完序之后，再把每个桶里的数据按照顺序依次取出，组成的序列就是有序的了。 换句话说：桶排序就是将待排序集合中处于同一值域的元素存入同一个桶中，也就是根据元素值特性将集合拆分成多个区域，则拆分后 ...
数据结构与算法（一）：基础数据结构（算法概念、数组、链表、栈、队列）
Men-DD
04-23 415
判断一个数是否是2的N次方？ 算法概念、数组、链表、栈、队列
数据结构之——栈
WenJieya的博客
03-27 6969
数据结构之——栈 一：栈的定义： 栈是限定是限定仅在表位进行插入和删除操作的线性表，栈又称为先进后出（Last In First Out）的线性表，简称LIFO结构。 栈顶：允许插入和删除的一端称为栈顶。 栈底：不可以进行插入和删除操作。 空栈：不含任何数据元素的栈称为空栈。 理解栈的定义需要注意几点： 1：它是一个线性表，即说明栈元素具有 线性关系，即 前驱后继 关系。只不 过它是一种特殊的线性表而已。 2：定义中说在线性表的表的表尾进行插入和删除操作，注意这里表尾指的是
数据结构：栈「详解」
weixin_56433857的博客
03-31 1万+
栈（Stack）是一种常见的数据结构，它是一种“后进先出”（Last In First Out，LIFO）的数据结构。栈可以看做是一种特殊的线性表，只能在栈顶进行插入和删除操作。栈顶是允许操作的，而栈底是固定的。
Java数据结构与算法-笔记-代码-课件-资料
05-17
内容包括: 稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、...
数据结构与算法-课件-代码-Python语言描述
10-23
在Python中，常见的数据结构有数组（list）、链表、栈（stack）、队列（queue）、字典（dictionary）、集合（set）等。数组提供了随机访问，但插入和删除操作较慢；链表则相反，插入和删除快速，但访问需要从头开始...
数据结构与算法----线性表及Java实现顺序表、链表、栈、队列 定义线性表节点的结构.pdf
04-18
数据结构与算法是程序设计的两大基础，大型的IT企业面试时也会出数据结构和算法的题目，它可以说明你是否有良好的逻辑思维，如果你具备良好的逻辑思维，即使技术存在某些缺陷，面试公司也会认为你很有培养价值，至少...
数据结构与算法-PPT课件
10-27
常见的数据结构有数组、链表、栈、队列、哈希表、树和图等。数组是最基础的数据结构，提供了随机访问但插入和删除操作相对较慢。链表则允许动态调整大小，但访问速度不如数组。栈和队列分别遵循“后进先出”（LIFO）...
数据结构与算法（3）栈
flyersboy的博客
04-22 698
栈 1、栈的一个实际需求 请输入一个表达式：7x2x2-5+1-5+3-3 2、栈的介绍 栈的英文为stack 栈是一个**先入后出(FILO-First In Last Out) **的有序列表 栈(stack) 是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 允许插入和删除的一端，为变化的一端，称为栈顶(Top) ，另一端为固定的一端，称为栈底(Bottom) 根据栈的定义可知 ，最先放入栈中元素在栈底 ，最后放入的元素在栈顶 删除元素刚好相反 ，最后
栈,队列和链表三者之间的关系与区别
老司机的后备箱
12-16 2154
为大家准备了一个前端资料包。包含54本，2.57G的前端相关电子书，《前端面试宝典（附答案和解析）》，难点、重点知识视频教程（全套）。 数组在内存中最为关键的一个特征，就是它一般是对应一段位于自己上界和下界之间的、一段**连续**的内存空间。元素与元素之间，紧紧相) 关系进行一下简化) 要想访问链表中的任何一个元素，我们都得从起点结点开始，逐个访问 next，一直访问到目标结点为止。
数据结构（栈/队列/链表）
weixin_47667133的博客
07-20 925
线性数据结构 2. 什么叫做数据结构 数据结构是计算机存储、组织数据的方式。指的是相互之间存在一种或多种特定关系的数据元素的集合。 ​ – 百度百科 可比喻成一个企业的组织结构，组织结构其实就是部门与部门之间的关系结构。 数据结构就是用来描述数据与数据之间的关系 线性和非线性数据结构 线性结构：数据元素之间一对一的关系 非线性结构：数据元素之间一对多的关系 存储方式 顺序存储：Set、Array 散列存储：Map、Object
数据结构01-线性结构-链表栈队列-栈篇
IT从业者的成长历程
07-18 328
本系列为C++数据结构系列，会介绍 线性结构，简单树，特殊树，简单图等。本文为线性结构部分。
链表、栈、队列
最新发布
qq_63915254的博客
11-24 1023
当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表其实位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特性。、非顺序的存储结构，数据元素的。
【图解数据结构】栈全面总结
热门推荐
知心宝贝的博客
12-23 1万+
一、前言 掌握栈这种抽象数据类型的特点，在相应的实际问题中正确应用 掌握栈类型的两种实现方法 二、基本概念 定义：只允许在一端进行插入或删除的线性表 栈顶（top）：允许进行插入或删除的一端 栈底（bottom）:与栈顶相对应的一端 特点：先进后出 三、栈的表示和实现 1.顺序栈 定义：一组地址连续的存储单元依次存放自栈底到栈顶的数据元素 top :用来表示栈顶元素的位置 top==-1表示空栈 top==NULL表示栈不存在 top>stacksize....
【数据结构】栈的详解
wangduduniubi的博客
05-18 1969
栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
数据结构之栈的详解
qq_45726327的博客
05-06 1502
栈是一种先入后出(FILO)的线性表数据结构添加和删除操作只在表的一端进行,这一端称为栈顶,另一端称为栈底添加操作又称入栈或进栈,删除操作又称出栈例如手枪的弹夹就是诸如此类的结构我这里做出简单的一个解释,简单来说就是后缀表达式,我这里做出一个简单的图示定义一个栈,用于存储操作数。遍历字符串数组tokens中的每个元素。如果当前元素不是运算符,则直接将其PARSE为整数并压入栈。如果当前元素是运算符,则弹出栈顶的两个操作数进行运算。根据运算符不同,进行加减乘除运算。将结果压入栈。
数据结构与算法解析：链表、栈、队列与二叉树
"该资源是一本由艾孜尔江编写的《数据结构算法大全》，主要针对面试中的数据结构和算法问题进行讲解，涵盖单链表、栈和队列、二叉树等多个主题，旨在帮助读者理解和掌握数据结构与算法的基础知识，提升面试竞争力。...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南岸青栀*

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值