备战秋招——记录自己学习的第一天（链表、栈、队列）

最新推荐文章于 2024-07-20 09:21:06 发布
最新推荐文章于 2024-07-20 09:21:06 发布
阅读量134 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41643663/article/details/90679929
版权

一、利用python实现单向链表

在程序中，经常需要将一组（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录它们，传进传出函数等。一组数据中包含的元素个数可能发生变化（可以增加或删除元素）。

对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种有意义的信息，或者表示数据之间的某种关系。

这样的一组序列元素的组织形式，我们可以将其抽象为线性表。一个线性表是某类元素的一个集合，还记录着元素之间的一种顺序关系。线性表是最基本的数据结构之一，在实际程序中应用非常广泛，它还经常被用作更复杂的数据结构的实现基础。

根据线性表的实际存储方式，分为两种实现模型：

顺序表，将元素顺序地存放在一块连续的存储区里，元素间的顺序关系由它们的存储顺序自然表示。
链表，将元素存放在通过链接构造起来的一系列存储块中。
为什么需要链表
顺序表的构建需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁，所以使用起来并不是很灵活。

链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。

链表的定义
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是在每一个节点（数据存储单元）里存放下一个节点的位置信息（即地址）。最后一个节点指向None。

单链表的操作
is_empty() 链表是否为空
length() 链表长度
travel() 遍历整个链表
add(item) 链表头部添加元素
append(item) 链表尾部添加元素
insert(pos, item) 指定位置添加元素
remove(item) 删除节点
search(item) 查找节点是否存在

首先，我们先定义链表中的节点

"""单链表的节点"""
def __init__(self,item):
    """设置单链表的值"""
    self.item = item
    """设置单链表指向的地址"""
    self.next = None入代码片`

创建单链表，其中封装着头结点：

class SingleLinkList(object):
    """创建单向链表"""
    def __init__(self,node = None):
        """创建头结点"""
        self.__head = node

判断链表是否为空：

    def is_empty(self):
        """链表是否为空"""
        return self.__head == None

求出链表长度：

    def length(self):
        """链表的长度"""
        cur = self.__head
        """定义指针"""
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
            """定义下一个指针"""
        return count

遍历整个列表，将其中数据输出输出：

    def travel(self):
        """遍历整个链表"""
        cur = self.__head
        while cur != None:
            print(cur.item)
            cur = cur.next

在链表头部添加首节点：

    def add(self,item):
        """链表头部添加元素"""
        node = SingleNode(item)
        node.next = self.__head
        self.__head = node

添加尾节点：

    def append(self,item):
        """链表尾部添加元素"""
        node = SingleNode(item)
        cur = self.__head
        if self.is_empty():
            self.add(item)
        else:
            while cur.next != None:
                cur = cur.next
            cur.next = node

任意位置插入节点：

    def insert(self,pos,item):
        """指定位置添加元素"""
        node = SingleNode(item)
        cur = self.__head
        if pos<=0:
            self.add(item)
        elif pos + 1 >self.length():
            self.append(item)
        else:
            for i in range(0,pos-1):
                cur=cur.next
            node.next = cur.next
            cur.next = node

删除节点：

 def remove(self,item):
        """删除节点"""
        cur = self.__head
        pre = None
        if cur.item ==item:
            self.__head = cur.next
        else:
            for i in range(0,self.length()+1):
                if item == cur.item:
                    pre.next = cur.next
                else:
                    pre = cur
                    cur = cur.next

查找节点是否存在：

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

下面进行程序验证：

if __name__ == "__main__":
    li = SingleLinkList()
    li.add(5)
    li.add(4)
    li.add(70)
    li.append(100)
    li.insert(50,30)
    li.remove(70)
    print(li.search(1000))
    li.travel()

结果图：

在这里插入图片描述

二、利用python实现双向链表

双向链表
一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。
与单向链表的不同之处在于，除了首节点，每个节点多了都会指向前一个节点的地址，下面我们在单向链表的基础上进行修改：

class SingleNode(object):
    """单链表的节点"""
    def __init__(self,item):
        """设置单链表的值"""
        self.item = item
        """设置单链表指向的地址"""
        self.next = None
        self.prev = None


class DoubleLinkList(object):
    """创建双向链表"""
    def __init__(self,node = None):
        """创建头结点"""
        self.__head = node

    def is_empty(self):
        """链表是否为空"""
        return self.__head == None



    def length(self):
        """链表的长度"""
        cur = self.__head
        """定义指针"""
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
            """定义下一个指针"""
        return count


    def travel(self):
        """遍历整个链表"""
        cur = self.__head
        while cur != None:
            print(cur.item)
            cur = cur.next


    def add(self,item):
        """链表头部添加元素"""
        node = SingleNode(item)
        if self.is_empty():
            node.next = self.__head
            self.__head = node
            self.__head.prev = node
        else:
            node.next = self.__head
            self.__head = node



    def append(self,item):
        """链表尾部添加元素"""
        node = SingleNode(item)
        cur = self.__head
        if self.is_empty():
            self.add(item)
        else:
            while cur.next != None:
                cur = cur.next
            node.prev = cur
            cur.next = node

    def insert(self,pos,item):
        """指定位置添加元素"""
        node = SingleNode(item)
        cur = self.__head
        if pos<=0:
            self.add(item)
        elif pos + 1 >self.length():
            self.append(item)
        else:
            for i in range(0, pos - 1):
                cur=cur.next
            node.next = cur.next
            cur.next.prev = node
            cur.next = node
            node.prev = cur


    def remove(self,item):
        """删除节点"""
        if self.is_empty():
            return
        else:
            cur = self.__head
            if cur.item == item:
                # 如果首节点的元素即是要删除的元素
                if cur.next == None:
                    # 如果链表只有这一个节点
                    self.__head = None
                else:
                    # 将第二个节点的prev设置为None
                    cur.next.prev = None
                    # 将_head指向第二个节点
                    self.__head = cur.next
                return
            while cur != None:
                if cur.item == item:
                    # 将cur的前一个节点的next指向cur的后一个节点
                    cur.prev.next = cur.next
                    if cur.next:
                    # 将cur的后一个节点的prev指向cur的前一个节点
                        cur.next.prev = cur.prev
                    break
                cur = cur.next

    def search(self,item):
        """查找节点是否存在"""
        cur = self.__head
        while cur != None:
            if item == cur.item:
                return True
            cur = cur.next
        return False
 if __name__ == "__main__":
    ll = DoubleLinkList()
    ll.append(1)
    ll.append(2)
    ll.append(3)
    ll.append(4)
    ll.insert(2,100)
    ll.add(5)

    ll.remove(100)
    ll.travel()

**结果如下：**
	5
	1
	2
	3
	4

三、利用python实现单项循环链表

单向循环链表
单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。
操作
is_empty() 判断链表是否为空
length() 返回链表的长度
travel() 遍历
add(item) 在头部添加一个节点
append(item) 在尾部添加一个节点
insert(pos, item) 在指定位置pos添加节点
remove(item) 删除一个节点
search(item) 查找节点是否存在


class SingleNode(object):
    """单项循环链表的节点"""
    def __init__(self,item):
        """设置单链表的值"""
        self.item = item
        """设置单链表指向的地址"""
        self.next = None


class SinCycLinkedlist(object):
    """创建单向链表"""
    def __init__(self,node = None):
        """创建头结点"""
        self.__head = node

    def is_empty(self):
        """链表是否为空"""
        return self.__head == None



    def length(self):
        """链表的长度"""
        if self.is_empty():
            return 0
        else:
            cur = self.__head
            """定义指针"""
            count = 1
            while cur.next != self.__head:
                count += 1
                cur = cur.next
                """定义下一个指针"""
            return count


    def travel(self):
        """遍历整个链表"""
        if self.is_empty():
            return
        else:
            cur = self.__head
            while cur.next != self.__head:
                print(cur.item)
                cur = cur.next
            print(cur.item)


    def add(self,item):
        """链表头部添加元素"""
        node = SingleNode(item)
        if self.is_empty():
            self.__head = node
            node.next = self.__head
        else:
            node.next = self.__head
            cur = self.__head
            # self.__head = node    #这一步不能写在这里，因为会对cur的值发生改变
            while cur.next != self.__head:
                cur = cur.next
            cur.next = node
            self.__head = node


    def append(self,item):
        """链表尾部添加元素"""
        node = SingleNode(item)
        cur = self.__head
        if self.is_empty():
            self.add(item)
        else:
            while cur.next != self.__head:
                cur = cur.next
            cur.next = node
            node.next = self.__head

    def insert(self,pos,item):
        """指定位置添加元素"""
        node = SingleNode(item)
        cur = self.__head
        if pos<=0:
            self.add(item)
        elif pos + 1 >self.length():
            self.append(item)
        else:
            for i in range(0,pos-1):
                cur=cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        """删除一个节点"""
        # 若链表为空，则直接返回
        if self.is_empty():
            return
        # 将cur指向头节点
        cur = self.__head
        pre = None
        # 若头节点的元素就是要查找的元素item
        if cur.item == item:
            # 如果链表不止一个节点
            if cur.next != self.__head:
                # 先找到尾节点，将尾节点的next指向第二个节点
                while cur.next != self.__head:
                    cur = cur.next
                # cur指向了尾节点
                cur.next = self.__head.next
                self.__head = self.__head.next
            else:
                # 链表只有一个节点
                self.__head = None
        else:
            # 第一个节点不是要删除的
            while cur.next != self.__head:
                # 找到了要删除的元素
                if cur.item == item:
                    # 删除
                    pre.next = cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
            # cur 指向尾节点
            if cur.item == item:
                # 尾部删除
                pre.next = cur.next


    def search(self,item):
        """查找节点是否存在"""
        cur = self.__head
        if self.is_empty():
            return
        else:
            while cur !=  self.__head:
                if item == cur.item:
                    return True
                cur = cur.next
            if item == cur.item:
                return True
            else:
                return False


"""for 循环无法终止程序，所以必须要用while来停止
        for i in range(0,self.length()+1):
            if item == cur.item:
                return True
            cur = cur"""




if __name__ == "__main__":
    li = SinCycLinkedlist()

    li.add(5)
    li.append(100)
    li.add(4)
    li.insert(1,200)
    li.remove(100)
    # print(li.length())
    li.travel()
**结果如下：**
	4
	200
	5

四、利用顺序表（为了方便起见，使用python中自带的顺序表——list，也可以对前三个结构进行封装）实现栈的功能。

让我们介绍一下什么是栈。
栈（stack），有些地方称为堆栈，是一种容器，可存入数据元素、访问元素、删除元素，它的特点在于只能允许在容器的一端（称为栈顶端指标，英语：top）进行加入数据（英语：push）和输出数据（英语：pop）的运算。没有了位置概念，保证任何时候可以访问、删除的元素都是此前最后存入的那个元素，确定了一种默认的访问顺序。

由于栈数据结构只允许在一端进行操作，因而按照后进先出（LIFO, Last In First Out）的原理运作。
在这里插入图片描述



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):
        if self.__list:
            return self.__list[-1]
        else:
            return None

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

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


s = Stack()
s.push(1)
s.push(2)
s.push(3)
s.push(4)
print(s.size())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())

**结果如下：**
	4
	4
	3
	2
	1

五、队列

**队列（queue）**是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出的（First In First Out）的线性表，简称FIFO。允许插入的一端为队尾，允许删除的一端为队头。队列不允许在中间部位进行操作！假设队列是q=（a1，a2，……，an），那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，总是在队列最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后。

#__author:"zhnag san pang"
#date: 2019/5/29

#__author:"zhnag san pang"
#date: 2019/5/29

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

    def enqueue(self,item):
        self.__list.insert(0,item)

    def dequeue(self):
        return self.__list.pop()

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

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


s = Queue()
s.enqueue(4)
s.enqueue(3)
s.enqueue(2)
s.enqueue(1)
print(s.size())
print(s.dequeue())
print(s.dequeue())
print(s.dequeue())
print(s.dequeue())

**结果如下：**
	4
	4
	3
	2
	1
在这里，我们引出
**双端队列**
双端队列（deque，全名double-ended queue），是一种具有队列和栈的性质的数据结构。

双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。
class Deque(object):
    def __init__(self):
        self.__list = []

    def add_front(self,item):
        self.__list.insert(0,item)

    def add_rear(self,item):
        self.__list.append(item)

    def remove_front(self):
        return self.__list.pop(0)

    def remove_rear(self):
        return self.__list.pop()

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

    def size(self):
        return len(self.__list)
睡着了都在敲代码
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【面试题】链表、栈和队列
白夜行
08-07 939
1.顺序存储结构 顺序存储结构,即数组。优点：节省存储空间，随机存取表中元素；缺点 ：插入和删除操作需要移动元素 顺序存储结构的插入与删除操作代码实现 public void insert(int data){ if (length >= size){ System.out.println("已存满"); return;
剑指Offer —— 面试题（一）
想要进大厂的螺丝钉的博客
07-07 143
秋招面试题
链表、栈和队列学习（一）
剑啸江湖
01-21 1781
  链表中的元素都是一个包含三个域的对象：一个关键字（或数据）域：data；两个指针（或链）域：next和prev；根据指针域的不同可以把链表细分为：单链表，双链表，循环链表及静态链表。 下面以单链表为研究对象来介绍链表的基本运算。单链表的C语言描述： typedef struct node{     int data;    /*数据域*/     struct node *next
py必须知道的干货-1
u011644858的博客
10-26 290
1、py的快捷键之 ctrl+n表示新建一个窗口 F5表示进入程序2、实现字符串的拼接a = input('请输入一个字符') b = input('请输入一个字符') print('{}{}'.format(a,b))3、九九乘法表 为了换行有两个PRINT函数for i in range(1,10):
用Python实现链表：用单向链表实现栈（元素进栈）
chenyuxiang0425的博客
10-27 1517
用Python实现链表：用单向链表实现栈（元素进栈） 用单向链表实现元素进栈大概分为以下几个步骤； 创建节点 用链表的头部插入/删除元素 元素进栈 1.创建节点 _Node类的构造函数是为了方便而设计，它允许为每个新创建的节点赋值。 由于 python 没有指针，因此一般使用类的结构实现指向关系。 例如： class TreeNode: # 类的结构包含了指向关系 ...
备战秋招——记录自己学习的第五天（刷题之剑指offer——二维数组查找、空格替换、打印链表、重建二叉树、用栈实现队列）
weixin_41643663的博客
06-04 146
题目描述 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 代码实现如下： # -*- coding:utf-8 -*- class Solution: # array 二维列表 def Find(self, target, array):...
备战秋招，面试知识点总结:操作系统（四）
weixin_30918415的博客
08-12 1474
进程与线程的概念，以及为什么要有进程线程，其中有什么区别 进程是对运行时程序的封装，是系统进行资源调度和分配的基本单位，实现了操作系统的并发； 线程是进程的子任务，是CPU调度和分派的基本单位，用于保证程序的实时性，实现进程内部的并发。线程是操作系统可识别的最小执行和调度单位。每个线程都独自占用一个虚拟处理器：独自的寄存器组，指令计数器和处理器状态。每个线程完成不同的任务，但是共享同...
大三、研二的秋招备战路线(Java、大数据)
WantFlyDaCheng的博客
06-01 251
出自公众号：大数据肌肉猿一、写作背景二、秋招的意义三、不同水平的同学备战秋招的策略(案例)四、部分面试题整理五、准备过程中的注意事项六、针对简历复习一、写作背景1.分享经...
闭关28天，奉上[Java一线大厂高岗面试题解析合集]，备战金九银十
m0_71563599的博客
08-29 320
时间不等人，2022年转眼就要过去大半了，春招在疫情中度过，不知有多少人还在惋惜... 马上又是秋招的高峰“金九银十”，估计现在就已经有不少的程序猿（媛）朋友早就踏上提前批之路了吧，机会来临，好好把握，争取一举上岸！...
第二章 栈、队列、链表.zip
03-03
队列是一种特殊的线性结构，它只允许在队列的首部（head）进行删除操作，这称为“出队”，而在队列的尾部（tail）进行插入操作，这称为“入队”。当队列中没有元素时（即 head==tail），称为空队列。我们称为“先进...
使用python实现数组、链表、队列、栈的方法
09-18
数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。这篇文章主要介绍了使用python实现数组、链表、队列、栈的相关知识,需要的朋友可以参考下
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
C语言 链表、队列、栈
01-08
链表 通用结点 typedef struct _node{//结点 int value; struct _node *next; }Node; 头结点和尾结点 typedef struct list{//链表 Node* head; Node* tail; }List; 基本链表 存入一连串整数遇到-1结束 #...
线性表、链表、栈、队列.rar
09-11
线性表、链表、栈和队列是计算机科学中基础且重要的数据结构，它们在程序设计和算法实现中有着广泛的应用。以下是对这些概念及其基本操作的详细说明。 线性表是一种基本的一维数据结构，它包含一个有限序列的元素，...
排序算法(4)之快速排序(1)
wer24_25的博客
07-17 1093
排序算法(4)之快速排序(1),快速排序的概念和快速排序的三种实现方式.
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 205
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 244
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
插入和选择排序
最新发布
c23856的博客
07-20 287
我们来计算一下它的时间复杂度：我们知道时间复杂度是计算最坏的情况，在这里的最坏情况为逆序，因为逆序的时候每次插入都需要执行前面数的数量，那么我们假设其有N个数，那么总执行量就为：1+2+3...+N-1 即为(N^2)/2。时间复杂度：O(N*logN),我们设该树高为h，那么树的所有节点为N=2^h-1个，我们的时间复杂度要换成与数量有关的式子，所以时间复杂度为O(N*logN).希尔排序是在插入排序的基础上，效率更高的排序，其实就是在插入排序的基础上加上了与预排序的操作。
栈和队列数据结构：链表栈类定义与实现
该资源是一份关于栈和队列学习的课件，主要讲解了链表栈类的定义以及栈和队列的基本概念、存储结构和应用。 在计算机科学中，栈和队列是两种重要的数据结构。栈被称为后进先出（LIFO，Last In First Out）的数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值