python数据结构——链表总结

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

python数据结构——链表

文章目录

单链表

概述

数据结构是计算机科学必须掌握的一门学科，在C语言中，可以使用“指针+结构体”来实现链表；而在python中，则可以采用“引用+类”来实现链表。

链表的定义：是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。

链表的结构：data 为自定义的数据，next为下一个节点的地址，head为保存首位节点的地址：

在这里插入图片描述

img

单向链表实现：

单向链表(单链表)是链表的一种，它由节点组成，每个节点都包含下一个节点的指针。

示意图：

这里参考了关于链表的实现原理：传送门

在这里插入图片描述

单链表删除节点：

在这里插入图片描述

单链表增加节点：

单链表的特点是：节点的链接方向是单向的；相对于数组来说，单链表的的随机访问速度较慢，但是单链表删除/添加数据的效率很高。

class Node:
    def __init__(self,data):
        self.data = data
        self.next = None

class chain:
    def __init__(self):
        self.head = None

    def is_empty(self):
        return not self.head

    def length(self):
        count = 0
        cur = self.head
        while cur != None:
            count += 1
            cur = cur.next

        return count

    def add(self,data):
        node = Node(data)
        node.next = self.head
        self.head = node

    def append(self,data):
        cur = self.head
        while cur.next != None:
            cur = cur.next
        node = Node(data)
        cur.next = node

    def traverse(self):
        cur = self.head
        while cur != None:
            print(cur.data, end='-***-')
            cur = cur.next
        print()

    def insert(self,index,data):

        if index < 0:
            self.add(data)
        elif index > self.length() -1:
            self.append(data)
        else:
            cur = self.head
            for i in range(index - 1):
                cur = cur.next

            node = Node(data)
            node.next = cur.next
            cur.next = node

    def remove(self,data):
        cur = self.head
        pre = None
        while cur != None:
            if cur.data == data:
                if cur == self.head:
                    self.head = self.head.next
                    return
                pre.next = cur.next #前节点等于后节点
                return
            pre = cur
            cur = cur.next

    def search(self, data):
        cur = self.head
        while cur != None:
            if cur.data == data:
                print("数据%f存在于链表中" % cur.data)
                return True
            cur = cur.next
        print("数据不存在于链表中")
        return False

if __name__ == '__main__':
    chain = chain()
    chain.add(0)
    chain.traverse()
    for i in range(1,9):
        chain.append(i)
    chain.traverse()
    chain.length()
    chain.insert(3,100)
    chain.traverse()
    chain.remove(100)
    chain.traverse()
    chain.insert(-2,99)
    chain.traverse()
    chain.insert(100,1000)
    chain.traverse()
    chain.search(5)
>>>
0-***-
0-***-1-***-2-***-3-***-4-***-5-***-6-***-7-***-8-***-
0-***-1-***-2-***-100-***-3-***-4-***-5-***-6-***-7-***-8-***-
0-***-1-***-2-***-3-***-4-***-5-***-6-***-7-***-8-***-
99-***-0-***-1-***-2-***-3-***-4-***-5-***-6-***-7-***-8-***-
99-***-0-***-1-***-2-***-3-***-4-***-5-***-6-***-7-***-8-***-1000-***-
数据5.000000存在于链表中

单链表优化

class Node:
    def __init__(self, elem, next_=None):
        self.elem = elem
        self.next_ = None

class Llist:
    def __init__(self):
        self._head = None

    def is_empty(self):
        return self._head == None  #is和== 的差别

    def length(self):
        cur = self._head
        count = 0
        while cur != None:
            count += 1
            cur = cur.next_
        return count

    def add(self,data):  # 头元素的添加
        node = Node(data)
        node.next_=self._head
        self._head = node

    def append(self,data):
        if self.is_empty():
            self.add(data)
        else:
            cur = self._head
            while cur.next_ != None:
                cur = cur.next_

            node = Node(data)
            cur.next_ = node

    def insert(self, data, index):
        if index <= 0:
            self.add(data)
        elif index > self.length():
            self.append(data)
        else:
            cur = self._head
            for i in range(index-1):
                cur = cur.next_
            node = Node(data)
            node.next_ = cur.next_
            cur.next_ = node

    def remove_By_data(self,data):# 按照元素值删除
        if self.is_empty():
            print("None")
        else:
            cur = self._head
            pre = None
            while cur != None:
                if cur.elem == data:
                    if cur == self._head: # 头没有前节点
                        self._head = self._head.next_
                        return
                    pre.next_ = cur.next_
                pre = cur
                cur = cur.next_

    def remove_By_index(self,index): #按照位置删除

        if index ==0:
            self._head = self._head.next_

        else:
            cur = self._head
            pre = None
            for i in range(index):
                pre = cur
                cur = cur.next_
            pre.next_ = cur.next_


    def delet_all(self):
        if self.is_empty():
            return
        else:
            self._head = None

    def find_data(self, data):
        cur = self._head
        count = 0
        while cur != None:
            if cur.elem == data:
                print("数据：%.2f  坐标：%d"%(cur.elem,count))
                return
            count += 1
            cur = cur.next_

    def travle(self):
        cur = self._head
        while cur != None:
            print(cur.elem,end="-***-")
            cur = cur.next_
        print()


if __name__ == '__main__':
    chain = Llist()
    chain.add(1)
    chain.travle()
    chain.append(0)
    chain.travle()
    chain.insert(2,1)
    chain.travle()
    chain.find_data(2)
    chain.insert(3, 1)
    chain.find_data(2)
    chain.travle()
链表尾端插入优化

前面的单链表实现有一个缺点：尾端加入元素操作时的效率低下，因为每次都是从头端开始查找None指针
现在提出一种可行性设计，其中在表对象中加入一个表尾端引用域，只需要常量时间都能找到尾节点。
在这里插入图片描述

class UnorderedList(Llist):
    '''单向链表'''

    def __init__(self):
        # 头结点
        self._head = None
        # 尾结点(这是保证时间复杂度为O(1)的关键)
        # 因为始终实时跟踪尾结点，所以不需要遍历
        self.tail = None

    def add(self, val):
        '''这是向链表头部添加节点的方法'''
        temp = Node(val)
        temp.next = self._head
        self._head = temp
        # 如果链表是空的，表示这是第一个添加的节点
        # 那么它就应该是尾结点
        if self.tail is None:
            self.tail = self._head

    def append(self, val):
        '''这是向链表的尾部添加节点的方法'''
        # 如果现在链表还是空的
        # 那么append和add做的事情是一样的，所以直接调用add就行了
        if self.tail is None:
            self.add(val)
        # 如果当前链表不为空
        # 那么就把新节点拼接到链表的末尾
        else:
            self.tail.next = Node(val)
            self.tail = self.tail.next

循环单链表

class Node(object):
    def __init__(self, value):
        # 元素域
        self.value = value
        # 链接域
        self.next = None


class CircularLinkedListOneway(object):
    def __init__(self, node=None):
        # 构造非空链时，让其地址域指向自己
        if node:
            node.next = node
        self.__head = node

    def is_empty(self):
        # 头节点不为None则不为空
        return self.__head == None

    def __len__(self):
        count = 1
        cur = self.__head
        if self.is_empty():
            return 0
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count

    def traversal(self):
        if self.is_empty():
            return
        cur = self.__head
        while cur.next != self.__head:
            print(cur.value)
            cur = cur.next
        # 退出循环时，cur正是尾节点
        print(cur.value)

    def add(self, value):
        """头插法"""
        node = Node(value)
        if self.is_empty():
            self.__head = node
            self.__head.next = self.__head
            return
        cur = self.__head
        while cur.next != self.__head:
            cur = cur.next
        # 新节点的next指针指向原头节点
        node.next = self.__head
        # 将新节点指向头节点
        self.__head = node
        # 尾节点next指针指向新头节点
        cur.next = self.__head

    def append(self, value):
        node = Node(value)
        cur = self.__head
        if self.is_empty():
            self.__head = node
            self.__head.next = self.__head
            return
        while cur.next != self.__head:
            cur = cur.next
        node.next = cur.next
        cur.next = node

    def insert(self, pos, value):
        if pos <= 0:
            self.add(value)
        elif pos > len(self) - 1:
            self.append(value)
        else:
            node = Node(value)
            cur = self.__head
            count = 0
            while count < pos - 1:
                count += 1
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def search(self, value):
        if self.is_empty():
            return False
        cur = self.__head
        while cur.next != self.__head:
            if cur.value == value:
                return True
            else:
                cur = cur.next
        # 别忘了while循环外的尾节点
        if cur.value == value:
            return True
        return False

    def remove(self, value):
        cur = self.__head
        prior = None
        if self.is_empty():
            return
        while cur.next != self.__head:
            # 待删除节点如果找到
            if cur.value == value:
                # 待删除节点在头部
                if cur == self.__head:
                    rear = self.__head
                    while rear.next != self.__head:
                        rear = rear.next
                    self.__head = cur.next
                    rear.next = self.__head
                # 待删除节点在中间
                else:
                    prior.next = cur.next # 这里不是跳出循环的break,而是退出函数的return哦,因为已经处理完毕了
                return
            # 如果还没找到
            else:
                prior = cur
                cur = cur.next
        # 待删除节点在尾部
        if cur.value == value:
            # 如果链表中只有一个元素，则此时prior为None，Next属性就会报错
            # 此时直接使其头部元素为None即可
            if cur == self.__head:
                self.__head = None
                return
            prior.next = cur.next

if __name__ == '__main__':
    chain = CircularLinkedListOneway()
    chain.add(1)
    chain.append(2)
    chain.traversal()
风鸣万象
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python数据结构——链表
weixin_44740082的博客
09-10 142
由于python没有指针，所以将结点封装成类，将其元素值和next作为类的属性 在建立一个链表类对及诶单进行操作 在进行添加，删除等操作时，每次都要注意特殊情况：链表是否为空，链表只有一个元素，进行操作的元素的头结点或者为尾结点等 单链表 class Node(object): #节点 def __init__(self,elem): self.elem=elem ...
【数据结构】链表的python实现
Luqiang_Shi的博客
04-16 301
【数据结构】链表的python实现一、单向链表的python实现二、双向链表的python实现 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表中的元素可以存在内存中的任何位置。单向链表的节点包含该节点的元素值和下一个节点的地址，双向链表的节点包括该节点的元素值、上一个节点的地址和下一个节点的地址。 一、单向链表的python实现 clas...
【Python——链表】
m0_70964767的博客
08-05 1万+
链表（Linked list）是一种常见的基础数据结构，是一种线性表，在每一个节点（数据存储单元）里存放下一个节点的位置信息。
数据结构——链表（python版）
点赞的都能无bug通过！
05-05 5427
结点的数据结构为数据元素(item)与 指针(next)class Node(object) : """单链表的结点""" def __init__(self , item) : # item存放数据元素 self . item = item # next是下一个节点的标识 self . next = None链表需要具有首地址指针head。class SingleLinkList(object) : """单链表""" def __init__(self) : self . _head = None。
python数据结构 —— 链表
最新发布
2301_77774241的博客
05-15 674
简要介绍了链表这一数据结构，并且详细介绍了如何进行链表初始化、打印列表、append和pop操作
Python 数据库——链表
思则变的专栏
09-12 2822
链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表在逻辑上是连续的，但是在物理空间上可能是不连续的，因为链表的内存都是临时申请的，不一定会申请到连续的内存空间。常用的链表有单向链表和双向链表。这里主要介绍单项链表。单项链表的组成节点有两部分构成：数据和下一个列表的存储地址。单节点结构图：链表结构图：可以看到每一个节点中的addr都指向下一个节点的地址，phead为整个链表的头节点，不能改变，否则就会找不到整个链表。
【Python】python链表
热门推荐
weixin_45718987的博客
05-31 2万+
python链表总结 原Blog链接：https://blog.csdn.net/qq_44941689/article/details/122402938 1. 链表基本类型 链表（Linked List）：一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。即「链表」 是实现线性表的链式存储结构的基础。 单链表每个数据元素占用若干存储单元的组合称为一个「链节点」，还要存放一个指出这个数据元素在逻辑关系上的直接后继元素所在链节点的地址，该地址被
Python实现链表介绍
cnds123的专栏
02-17 2770
C语言是通过指针将节点连接成链表和树结构的。Python没有指针怎么实现链表？本文以最简单的单链表为例介绍。
图解数据结构（使用Python）——链表
12-21
概念：链表（Linked List）是由许多相同数据类型的数据按特定顺序排列而成的线性表，其特点是各个数据在计算机内存中的位置是不连续且随机的。 优点： 数据的插入和删除都比较方便，不需要移动大量的数据（列表在...
Python数据结构实战——链表(LinkedList)
12-21
链表中插入一堆数据2.8.完整代码+测试 1.定义结点类 class Node: def __init__(self,data=None,next=None): #传入值和指针 self.data = data #data赋值 self.next = next #next赋值 2.定义链表类 class ...
Python实现数据结构与算法——反转链表
12-21
题目描述： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道...这个过程相当于，在遍历链表的过程中，每一个当前节点的nex
数据结构与算法 Python语言描述 ——裘宗燕版
07-05
《数据结构与算法 Python语言描述》是裘宗燕编著的一本专著，它深入浅出地介绍了数据结构和算法的基础知识，特别是如何利用Python语言进行实现。这本书以高清且带有目录的形式，使得读者能够方便地查找和学习相关...
python数据结构与算法详解与源码
08-20
数据结构与算法（Python） 一、引入概念 1-01算法引入 1-02 时间复杂度与大O表示法 1-03-最坏时间复杂度与计算规则 1-04-常见时间复杂度与大小关系 1-05-代码执行时间测量模块 1-06-Python列表类型不同操作的...
链表基础知识与题目整理(Python)
A496608119的博客
01-12 1254
1.链表简介 1.1 链表定义 链表(Linked List)： 一种线性表数据结构。它使用一组任意的存储单元（可以是连续的，也可以是不连续的），来存储一组具有相同类型的数据。 比如单链表： 如上图所示，链表通过将一组任意的存储单元串联在一起。 链表节点： 每个数据元素占用若干存储单元的组合称为一个链接点。 链表节点的存储内容: 数据元素的值+后继指针（后继指针是指出这个数据元素在逻辑关系上的直接后继元素所在链节点的地址）。 数据之间的逻辑关系：逻辑关系是通过后继指针来简介反映的。逻辑上相邻的数据数素在物
python模拟实现链表_python实现链表
weixin_39664746的博客
11-20 368
数据结构是计算机科学必须掌握的一门学问，之前很多的教材都是用C语言实现链表，因为c有指针，可以很方便的控制内存，很方便就实现链表，其他的语言，则没那么方便，有很多都是用模拟链表，不过这次，我不是用模拟链表来实现，因为python是动态语言，可以直接把对象赋值给新的变量。好了，在说我用python实现前，先简单说说链表吧。在我们存储一大波数据时，我们很多时候是使用数组，但是当我们执行插入操作的时候就...
数据结构——链表（python）
Traceyfind的博客
08-03 635
链表的相关题目需要分为笔试和面试准备。*笔记的话可以不用考虑额外的空间复杂度，但是面试的话需要需要提升自己就利用原有的数据的情况下进行题目的解答的过程。
Python数据结构与算法篇（十一）-- 链表的应用与常见题型
CarpeDiem
03-14 1739
本篇信息量巨大，首先对比链表和数组，接着解决单链表的反转、删除某一节点、插入数据、查找中间节点、求倒数第k个结点、对称链表、单链表是否有环、两个链表是否相交，最后用LeetCode上的真题来实战删除链表结点、反转链表、合并、排序、环形链表常用技巧。
算法+Python - 链表
编码时光
05-06 345
单向链表 节点实现 单链表的操作 单链表的实现 头部添加元素 尾部添加元素 指定位置添加元素 删除节点 查找节点是否存在 测试 链表与顺序表的对比 单向循环链表 操作 实现 双向链表 操作 实现 指定位置插入节点 删除元素 测试
python链表所有操作详解
starmoth的博客
03-07 2382
一.插入操作 1.append操作 把一个元素添加到链表的结尾 a=[1,3,5,4,8,7] a.append(9) [1, 3, 5, 4, 8, 7, 9, 9] 2.extend操作 就是合并链表的操作 a=[1,3,5,4,8,7] b=[5,6,8] a.extend(b) [1, 3, 5, 4, 8, 7, 9, 9, 5, 6, 8] 3.insert操作 就是元素插入指定位...
哈希表设计与实现——链表法
05-10
哈希表是一种高效的数据结构，可以用来存储和查找键值对。其中，哈希函数将键映射到一个特定的桶中，每个桶中存储一组键值对。在哈希表中，如果两个键被映射到同一个桶中，就会发生碰撞。为了解决这个问题，可以使用链表法。 链表法是一种解决哈希表碰撞问题的方法。具体来说，对于哈希表中的每个桶，可以使用一个链表来存储所有映射到该桶的键值对。如果发生碰撞，只需要将新的键值对添加到链表的末尾即可。 下面是一个使用链表法实现哈希表的示例代码： ```python class Node: def __init__(self, key, value): self.key = key self.value = value self.next = None class HashTable: def __init__(self, capacity): self.capacity = capacity self.buckets = [None] * capacity def hash_function(self, key): return hash(key) % self.capacity def put(self, key, value): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: node.value = value return node = node.next new_node = Node(key, value) new_node.next = self.buckets[index] self.buckets[index] = new_node def get(self, key): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: return node.value node = node.next return None def remove(self, key): index = self.hash_function(key) node = self.buckets[index] prev = None while node: if node.key == key: if prev: prev.next = node.next else: self.buckets[index] = node.next return prev = node node = node.next ``` 在这个示例中，我们定义了一个Node类来表示哈希表中的每个节点，每个节点包含一个键、一个值和一个指向下一个节点的指针。我们还定义了一个HashTable类来实现哈希表，其中包含一个桶数组和一些基本的操作方法，如put、get和remove。 在put方法中，我们首先使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键是否已经存在于哈希表中。如果找到了该键，我们只需要更新其对应的值即可。否则，我们创建一个新的节点，并将其添加到链表的开头。 在get方法中，我们同样使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键的值。如果找到了该键，我们返回其对应的值。否则，返回None。 在remove方法中，我们首先使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键。如果找到了该键，我们将其从链表中删除即可。 总的来说，链表法是一种简单且常用的哈希表解决碰撞问题的方法。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值