单链表宇宙超级无敌完全（Python实现）

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

初步使用链表

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# 功能：
# 创建空表 删除表 判断表是否为空 判断表是否满 
# 首插 尾插 一般情况插入 
# 首删 尾删 一般情况和删
# 扫描、查找和遍历    1、按元素查找2、按下标查找
class LNode:    # 表节点类
    def __init__(self, elem, next_ = None):
        self.elem = elem
        self.next = next_

# 创建空链表
# head = LNode(None)

# 创建表头(创建链表)
head = LNode(0) #  head不变，需要使用的时候用一个中间变量（指针或游标）引用他

# 创建一些节点
pre = head
for i in range(1,10):
    # node = LNode(i)
    # pre.next = node
    pre.next = LNode(i)
    pre = pre.next
    # if i == 9:
    #     node.next = None

# 按下标定位，首节点下标为0
p = head
i = 5
while p is not None and i>0: 
    i = i-1     # 当i=1时执行最后一次循环，最后i=0
    p = p.next  
print('下标为5的元素：',p.elem)

p = head
for i in range(5):  # 打印下标为5的元素（第6个元素）
    if p is not None:
        p = p.next
print('下标为5元素:',p.elem)

# 按元素定位
p = head
while p is not None and (p.elem != 5):   # 打印节点元素为5的元素
    p = p.next
else:
    print('查询节点元素为5的元素：',p.elem)

# 头插：插在表头的前面（原来的head前面）
q = LNode(100)
q.next = head
head = q

# 遍历：打印所有节点
print('遍历：以下打印链表所有节点：')
p = head
while p is not None: # 节点存在就打印出节点元素
    print(p.elem) 
    p = p.next

# 求表长度： 表头+表节点+表尾
def length(head):
    p = head; cnt = 0 #计数习惯初始为0
    while p is not None: # p is None表示这个节点不存在，判断尾节点：p.next is None
        cnt = cnt + 1 # p is not None就加1
        p = p.next
    return cnt 

length = length(head)
print('链表长度为：',length)



# 头插,头插是插在head前面
# q = LNode(0)
# q.next = head
# head = q

# 中间插入:让游标pre指向待删除节点的前一节点、  即使pre指向的是尾节点可可以
# q = LNode(13)
# q.next = pre.next
# pre.next = q # 注意： 该语句不能和上一条语句顺序互换，如果先执行该条语句，链表插入位置的后面部分会被Python回收机制回收

# 尾插， 要先遍历一遍链表找到尾节点
# node = LNode(29)
# pre = head
# while  pre.next is not None:
#     pre = pre.next # 游标向后移动一位
# else:   
#     pre.next = node
#     node.next = None

#头删
# head = head.next

#一般删： pre指向需要删除节点的前一节点
# pre.next = pre.next.next

# 查找、遍历：对表中一切元素的检查都要从表头变量head开始
# p = head
# while p is not None ''' and (其他条件)''':
#     '''对p所指节点的操作'''
#     p = p.next #游标p向后移动一位


# 链表复杂度分析:

单链表

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

class LinkListUnderflow(ValueError): # 自定义异常类
    pass


class LNode:    # 表节点类（重要概念） -->该类的一个对象表示一个节点
    def __init__(self, elem, next_ = None):
        self.elem = elem
        self.next = next_

# 初始化一个链表玩一下
# list1 = LNode(1)
# p = list1
# for i in range(2,11):
#     p.next = LNode(i) # 一边循环，一边新增节点，同时让指针指向新增节点
#     p = p.next
# 打印每个元素出来看一下
# p = list1   
# while p is not None:
#     print(p.elem) 
#     p = p.next



###################
'''   单链表    '''
###################
# 节点类和单链表对象类的区别：
#   节点类：一个属性表示一个数据域或者指针域
#   单链表对象类：一个属性表示一个对象，这个对象是节点类实例化的对象，即一个节点
# 节点类实例化后的对象表示 --> 节点
# 单链表对象类实例化后的对象表示 -->  链表--汇集对象
class LList:    # 单链表对象类（重要概念） -->该类的属性是表节点类的对象
    def __init__(self):
        self._head = None # 这个是表头，表头代表链表，表头地址即表示链表地址，和数组一样：数组的地址就是第一个元素的地址
    
    def is_empty(self):
        return self._head is None

    # 头插
    def prepend(self, elem):
        # p = LNode(elem) # 创建新的节点对象p
        # p.next = self._head
        # self._head = p    # 注释的这三行等价于下面一行
        self._head = LNode(elem,self._head)     # ???使用LNode类

    #追加到表尾
    def append(self, elem):
        # 空表：一个节点都不存在，包括表头、中间节点、尾节点
        if self._head is None: # 如果是空表直接插在头结点后面，结束
            self._head = LNode(elem)
            return
        p = self._head
        while p.next is not None:
            p = p.next
        p.next = LNode(elem) # 表尾节点指向新创建的节点
    
    # 插入中间节点
    def insert(self, index, elem):
        if (self._head is None) and (self._head.next is None):
            raise LinkListUnderflow("in insert")
        p = self._head
        while p is not None and index>1: 
            index = index-1   
            p = p.next
        node = LNode(elem)
        node.next = p.next # 将新增节点先连上链表
        p.next = node # 断开前一节点，将前一节点指向新增节点  
        ###注意：一定要先连再断，如果先断开前一节点，Python回收机制会将该节点后的的部分回收，相当于删除了链表后面部分

    # 弹出表头元素
    def pop(self):
        if self._head is None:
            raise LinkListUnderflow('in pop')
        e = self._head.elem
        self._head = self._head.next
        return e

    # 弹出表尾元素
    def pop_last(self):
        if self._head is None: # 空表，一个节点也没有，在内存中为空
            raise LinkListUnderflow('in pop_last')
        p = self._head
        if p.next is None: # 表中只有一个元素，既是表头也是表尾
            e = p.elem
            self._head = None
            return e
        while p.next.next is not None:
            p = p.next
        e = p.next.elem
        p.next = None
        return e

    # 删除表中第一个元素为elem的节点
    def remove_any(self, elem): #两个游标，cur用来寻找elem,pre始终指向cur的前一个节点，待执行删除的时候用pre指向cur的后一节点
        pre = None
        cur = self._head
        while cur is not None:
            if cur.elem == elem:
                if pre is None: # cur是头结点
                    self._head = cur.next # head指向原头结点的下一个节点
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next
        else:
            raise LinkListUnderflow('in remove_any')
    
    # 删除所有元素为elem的节点
    def remove_elem_all(self,elem):
        pre = None
        cur = self._head
        while cur is not None:
            if cur.elem == elem:
                if pre is None:
                    self._head = cur.next
                else:
                    pre.next = cur.next
                cur = pre.next # 将cur指向删除节点的下一个节点
            else:
                pre = cur
                cur = cur.next
        
    def remove_any2(self, elem): # 一定要有一个游标指向待删除节点的前一个节点
        if self._head == None:
            raise LinkListUnderflow('in remove_any2')
        if self._head.elem == elem:
            self._head = self._head.next
            return
        p = self._head
        while p is not None and (p.next.elem != elem):
            p = p.next
        else:
            p.next = p.next.next 
    
    def remove_index(self,index):
        pre = self._head
        while pre is not None and index>1: # 让p指向待删除节点的前一节点
            index = index-1     
            pre = pre.next  
        pre.next = pre.next.next

    # 按照元素查询
    def find(slef, elem):
        p = self._head
        while p is not None:
            if p.elem == elem:
                return p.elem
            p = p.next

    # 按照下标查询
    def find_index(self, index):
        p = self._head
        while p is not None and i>0: 
            i = i-1     
            p = p.next  
        return p.elem
    
    def find_first(self):
        pass # 略
    
    def find_last(self):
        pass # 略

    # 遍历输出所有元素
    def printall(self):
        p = self._head
        while p is not None:
            print(p.elem,  end='')
            if p.next is not None:
                print(', ', end='')
            p = p.next
        print('')

    # 遍历执行某种操作proc
    # proc的实参是可以作用于表元素的操作函数，它将作用于表的每一个元素，这里以打印为例
    # proc常常可以用一个lambda表达式来定制
    def for_each(self, proc):
        p = self._head
        while p is not None:
            proc(p.elem)
            p = p.next
    
    # 定义迭代器
    def elements(self):
        p = self._head
        while p is not None:
            yield p.elem
            p = p.next
    
    # 筛选生成器，相比于定义迭代器，它加上了一个筛选的函数pred，我们把这个pred
    def find_filter(self,pred):
        p = self._head
        while p is not None:
            if pred(p.elem):
                yield p.elem
            p = p.next
    # 用于测试pred的方法 -->输出偶数
    def is_oddnumber(self,em):
        if em % 2 == 0:
            return True
        else:
            return False

    # 反转链表
    def reverse(self):
        pre = None
        cur = self._head
        while cur is not None:
            q = cur
            cur = q.next # 游标cur向后移动
            q.next = pre # 每次更改p节点的指向
            pre = q # 游标pre向后移动
        self._head = pre
        # 这里也可以不引入cur,全部用self._head替换，表示表头不断向后移动

# mylist = LList()
# for i in range(10):
#     mylist.prepend(i)
# for i in range(11,20):
#     mylist.append(i)
# mylist.prepend(10)

# mylist.insert(3,300)
# mylist.insert(4,300)
# mylist.insert(7,300)
# mylist.insert(8,400)
# mylist.insert(9,400)
# mylist.insert(11,400)
# mylist.remove_any(300)
# mylist.remove_elem_all(400)

# mylist.remove_index(1)

# mylist.printall()
# mylist.reverse() 
# mylist.printall()

# mylist.for_each(print) #以打印为例

# for x in mylist.elements():
#     print(x)

# for x in mylist.find_filter(mylist.is_oddnumber):
#     print(x)

单链表加上尾节点引用域

# 增加尾节点引用域
# 除了操作表头和表尾不一样，其他方法都一样可以使用
# 类设计要遵循内在的一致性
class LList1(LList):
    def __init__(self):
        LList.__init__(self) # 继承父类LList的初始化函数 
        self._rear = None # 尾节点引用域
        # self._head = None # head就是指向链表对象的引用，链表的头结点所在的地址表示链表的地址，相当于数组
    
    def prepend(self, elem):
        if self._head is None:
            self._head = LNode(elem, self._head)
            self._rear = self._head
        else:
            self._head = LNode(elem, self._head)
    
    def append(self,elem):
        if self._head is None:
            self._head = LNode(elem, self._head)
            self._rear = self._head # 这里_head的指针域是自己，这就等于_rear指向了尾节点 
        else:
            self._rear.next = LNode(elem)
            self._rear = self._rear.next
    
    def pop_last(self):
        if self._head is None:
            raise LinkListUnderflow('in pop_last')
        p = self._head
        if self._head.next is None:
            e = p.elem
            self._head = None
            return e
        while p.next.next is not None: # 把p.next看成一个节点在移动、或者判断循环终止的时候p是指哪一个节点
            p = p.next
        e = p.next.elem # 此时p.next是指尾节点
        p.next = None
        self._rear.next = p
        return e

# mylist2 = LList1() 
# mylist2.prepend(99)
# for i in range(1,10):
#     mylist2.append(i)
# for x in mylist2.find_filter(lambda y: y%2 == 1):
#     print(x)
# mylist2.pop_last()

循环单链表

# 单链表加上尾节点引用域：表尾查找和追加O(1),删除O(n)。因为删除需要通过遍历找到尾节点的前一个节点
# 循环单链表：表尾查找和追加O(1),删除O(n)
# 链表对象用来记录表尾节点更合适
# 循环单链表与普通单链表的差异：1、循环遍历的结束控制 2、没有表头引用域，所以单链表涉及表头的方法这里不能继承使用
class LCList: # 循环单链表类
    def __init__(self):
        self._rear = None #尾节点引用域

    def is_empty(self):
        return self._rear is None
    
    def prepend(self, elem):
        # p = LNode(elem)
        if self._rear is None:
            # p.next = p # 建立一个节点的环
            # self.-repr = p
            self._rear = LNode(elem)
            self._rear.next = self._rear
        else:
            # p.next = self._rear.next
            # self._rear.next = p
            self._rear.next = LNode(elem, self._rear.next)
        
    def append(self, elem):
        self.prepend(elem)
        self._rear = self._rear.next # 表尾改为追加的节点

    def pop(self):
        if self._rear is None:
            raise LinkListUnderflow("in pop")
        p = self._rear.next
        if self._rear is p:
            self._rear = None
        else:
            self._rear.next = p.next
        return p.elem
    
    def printall(self):
        if self.is_empty():
            return
        p = self._rear.next
        while True:
            print(p.elem, end=', ')
            if p is self._rear:
                break
            p = p.next

# mylist3 = LCList() 
# for i in range(1,10):
#     mylist3.prepend(i)
# for i in range(11,20):
#     mylist3.append(i)
# for x in mylist3.find_filter(lambda y: y%2 == 1):
#     print(x)
# mylist3.pop()
# mylist3.printall()
郑茂茂
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构：链表（Python语言实现）
2301_76884567的博客
03-16 5487
本文以单链表为例，用python创建一个单链表数据结构，同时定义链表节点的增加、删除、查询和打印操作。
Python-模拟单链表
wdzhgcs的博客
12-12 531
单链表中的第一个节点称为头节点，最后一个节点的下一个引用通常指向空值（None）python中实现模拟单链表还是比较简单的，文章如果有写的不对的或者写的不好的，欢迎大家指正。链表存储方式由于不需要按照顺序存储，在插入、删除元素时比顺序存储要快，但是在查找一个节点时要比顺序存储要慢。1、顺序表：将元素顺序的存放在一块连续的存储区里面，元素间的顺序关系由它们的存储顺序自然表示。2、链表：将元素存放在通过链接构造起来的一系列存储块中，存储区域是非连续的。线性结构：线性结构就是数据结构中各个结点具有线性关系。
【数据结构】链表
最新发布
小林的博客
05-12 418
​ 链表不同于顺序表，顺序表底层采用数组作为存储容器，需要分配一块连续且完整的内存空间进行使用，而链表不需要，它通过一个指针来连接各个分散的结点，形成了一个链状的结构，每个结点存放一个元素，以及一个指向下一个结点的指针，通过这样一个一个相连，最后形成了链表。​ 它不需要申请连续的空间，只需要按顺序连接即可，虽然物理上可能不想邻，但在逻辑上依然是每个元素相邻存放的，这种结构就叫链表（单链表）
(Python)知识点——链表篇
L念安dd的博客
03-23 119
Python链表知识点学习
python 实现栈和队列
算法笨蛋
01-10 1275
本文不涉及栈和队列概念的详细讲解，而着重利用 python 实现栈和队列，在其中穿插代码讲解。 目录栈队列 栈 栈实现数据的后进先出（LIFO）。 队列 队列实现数据的先进先出（FIFO）。
【数据结构连载一线性表】【单链表】python
hbk5241的博客
05-07 219
# -*- coding: UTF-8 -*- """ 线性表之链式存储结构 基本操作: 初始化 __init__ 线性表空判断 empty 清空线性表 clear 获取元素 get 是否存在数据 exist 插入操作 insert 删除操作 delete 线性表的长度 length 扩展操作 遍历链表 show
Python实现宇宙.rar
11-20
在Python编程语言中，"Python实现宇宙"这个标题可能指的是使用Python进行各种复杂科学计算、数据分析、可视化，甚至是模拟宇宙学中的模型。Python因其简洁易读的语法和强大的库支持，已经成为科研人员和数据科学家...
python版本单链表实现代码
12-24
今天看了一下数据结构的书，发现其实数据结构没有几种，线性表，数组，字符串，队列和栈，等等，其实是一回事，然后就是树结构，图结构。数据结构的理论并不难，主要是要自己写一下这些数据结构以及对应的基本的操作...
单链表反转python实现代码示例
12-23
单链表的反转可以使用循环，也可以使用递归的方式 1.循环反转单链表 循环的方法中，使用pre指向前一个结点，cur指向当前结点，每次把cur->next指向pre即可。 代码： class ListNode: def __init__(self,x): self...
超级无敌python
03-13
"超级无敌Python"这个标题暗示了这本书是针对初学者，旨在帮助他们在短时间内掌握Python的基础知识，并迅速提升编程能力。 **Python的特性** 1. **易学性**：Python的语法简洁明了，没有复杂的句法结构，使得初学...
python如何实现单链表的反转
09-17
主要介绍了python如何实现单链表的反转,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
python实现链表
热门推荐
Tonywu2018的博客
03-30 2万+
目录 1. 链表结构 1.1 单链表和双链表 1.2 非连续性内存和节点 1.3 定义并使用单链表节点类 2. 单向链表的操作 2.1 遍历 2.2 搜索 2.3 替换 2.4 插入 2.4.1 在开始处插入 2.4.2 在末尾插入 2.4.3 在任意位置插入 2.5 删除 2.5.1 在开始处删除 2.5.2 在末尾删除 2.5.3 在任意位置删除 2.6 单链...
数据结构与算法之Python实现——循环链表、双向循环链表
weixin_62917800的博客
11-05 2145
循环链表及双向循环链表保姆级讲解，一步一代码，并且最后还有具体应用的实现，进来看一下呗~
数据结构-第二期——链表（Python）
荷叶田田的博客
12-17 608
链表是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的链接。
链表及其python实现
suwuzs的博客
11-21 933
文章目录链表采用链表来实现无序表实现节点ListNode链表实现无序表UnorderList 链表 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。 由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。 数组是很常用的数据储存方式，而链表就是继
链表（python）
weixin_43765321的博客
03-19 2679
1. 链表定义 链表是由一系列节点组成的元素集合。每个节点包含两部分，数据域item和指向下一个节点的指针next。通过节点之间的相互连接，最终串联成一个链表。 单链表如下图所示： 单链表中的结点类型描述如下： class Node: def __init__(self, item): self.item = item self.next = None 2. 链表的实现方式 2.1 头插法 头插法从一个空表开始，生成新结点，并将读取到的数据存放到新结点的数据域中，
Python数据结构：链表
Python宋宋的专栏
06-06 3567
链表是一种在存储单元上非连续、非顺序的存储结构。数据元素的逻辑顺序是通过链表中的指针链接次序实现。链表是由一系列的结点组成，结点可以在运行时动态生成。每个结点包含两部分：数据域与指针域。数据域存储数据元素，指针域存储下一结点的指针。单向链表也叫单链表，是链表中最简单的形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。head 保存首地址，item 存储数据，next 指向下一结点地址。链表失去了序列的随机读取优点，同时链表增
122.找出单项链表中的最大值
u012814404的专栏
06-29 3635
N名学生的成绩已在主函数中放入一个带头节点的链表结构体中，h指向链表的头节点。fun函数的功能是：找出学生的最高分，由函数值返回。 #define _CRT_SECURE_NO_WARNINGS #include #include #define N 8 struct slist { double s; struct slist *next; }; typedef struct s
python 操作单链表(插入、删除、遍历)
sxf_123456的博客
08-10 5532
""" 单链表 1、计算长度操作 2、判断是否为空链表 3、头插法 4、尾插法 5、根据位置插入值 6、遍历链表 7、清空链表 8、根据位置删除链表值 9、根据值删除 10、链表逆序遍历 """ class Node(object): def __init__(self, value): self.value = value self.node = Non...
Python实现单链表
11-25
单链表是一种常见的数据结构，Python可以通过定义节点类和链表类来实现单链表。下面是一个简单的单链表实现示例： ``` class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def add_node(self, data): new_node = Node(data) if self.head is None: self.head = new_node return last_node = self.head while last_node.next: last_node = last_node.next last_node.next = new_node def print_list(self): current_node = self.head while current_node: print(current_node.data) current_node = current_node.next ``` 在这个示例中，我们定义了一个节点类Node，它有两个属性：data和next。data用于存储节点的数据，next用于指向下一个节点。然后我们定义了一个链表类LinkedList，它有一个属性head，表示链表的头节点。我们还定义了两个方法：add_node和print_list。add_node方法用于向链表中添加新节点，print_list方法用于打印链表中所有节点的数据。 使用示例： ``` linked_list = LinkedList() linked_list.add_node(1) linked_list.add_node(2) linked_list.add_node(3) linked_list.print_list() ``` 输出结果： ``` 1 2 3 ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值