数据结构----链表系列----单向链表---Python

最新推荐文章于 2020-02-02 16:42:45 发布
最新推荐文章于 2020-02-02 16:42:45 发布
阅读量167 收藏
点赞数
分类专栏： 剑指offer 文章标签： 数据结构 剑指offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mao123_4zxc/article/details/96139800
版权

数据结构----单向链表（linked list）

作者：程序员老九
掘金：https://juejin.im/post/5d132d91e51d4550a629b2ad
来源：请关注我的掘金博客

基础

我们知道什么是list，但是这不是链表。链表是由一系列的节点（Node）实现的，节点呢有至少两部分，一是数据，而是指向下一个节点的指针，如果没有指向，则指针指向Null。

创建链表

链表是由节点来实现的，也就是说链表的建立必然要先建立节点类。

# 首先要有一个节点类
class Node:#(一个是数据、一个是指针，默认指向None)
    def __init__(self,dataval):
        self.dataval = dataval
        self.nextval = None 
class S_List:
    def __init__(self):
        #假设第一个数据是headval
        self.headval = None
li = S_List()
#先把数据列出来，这已经是有数据Node了
li.headval = Node('Mon')
e2 = Node('Tue')
e3 = Node('Wed')
# 用指针连接节点，也就是设置指针
li.headval.nextval = e2
e2.nextval = e3
#打印地址
print(e2.nextval)
#打印shuju
print(e2.nextval.dataval)

链表遍历

就是在创建完链表之后，可以输入第一个节点的方式来遍历整个链表

# 首先要有一个节点类
class Node:#(一个是数据、一个是指针，默认指向None)
    def __init__(self,dataval):
        self.dataval = dataval
        self.nextval = None 
class S_List:
    def __init__(self):
        #假设第一个数据是headval
        self.headval = None
    #定义一个函数--->在链表末尾添加一个新的node,node一定至少有两个部分，一是数据、而是指针（其中指针可以是none）
    def append(self,newdata):
        #newdata表示传入的数据
        Newdata = Node(newdata) # 这句话的意思是，现在Newdata已经通过Node类成为了一个节点。
        # if语句是判断Newdata是不是第一个数据，也就是判断它是不是None。
        if self.headval is None:
            self.headval = Newdata 
            return self.headval
        #这是第一个节点的数据
        laste = self.headval
        '''判断条件---->判断节点的指针是否指向下一个节点.如果有下一个节点，就会一直指向下一个节点。
        如果没有下一个节点（也就是None），则会跳出循环。这时候链表已经创建起来了
        '''
        while laste.nextval:
            laste = laste.nextval
        laste.nextval = Newdata
        
     def show(self):
        #这样可以直接使用链表
        printval = self.headval
        while printval:
            print (printval.dataval)
            printval = printval.nextval
                        
li = S_List()
#先把数据列出来，这已经是有数据Node了
e1 = li.append('Mon')
# li.headval = Node('Mon')
e2 = li.append('Tue')
e3 = li.append('Wed')
# 用指针连接节点，也就是设置指针
# e1.nextval = e2
# e2.nextval = e3
# li.append('Mon')
li.show()

插入

插入元素是指将一个元素从一个已经存在的节点指向新插入的节点。

  • 插入开头
# 首先要有一个节点类
class Node:#(一个是数据、一个是指针，默认指向None)
    def __init__(self,dataval):
        self.dataval = dataval
        self.nextval = None 
class S_List:
    def __init__(self):
        #假设第一个数据是headval
        self.headval = None
    #定义一个函数--->在链表末尾添加一个新的node,这个node一定至少两个方面啊，
    #一是数据，而是指针
    def append(self,newdata):
        #只有数据
        Newdata = Node(newdata)
        # print(str(Newdata.nextval)+'&&&&&&&')
        if self.headval is None:
            self.headval = Newdata 
            # print(str(self.headval.dataval)+"******")
            return self.headval
        laste = self.headval
        # print(str(laste.dataval)+"******")
        #判断条件

        while laste.nextval:
            laste = laste.nextval
        laste.nextval = Newdata
        # print(str(laste.nextval.nextval)+'&&&&&&&')
    #插入链表开头
    def add_left(self,newdata):
    	Newnode = Node(newdata)
    	if self.headval is None:
            self.headval = Newnode 
            # print(str(self.headval.dataval)+"******")
            return self.headval
    def show(self):
        printval = self.headval
        while printval:
            print (printval.dataval)
            printval = printval.nextval
        
       
        
        
li = S_List()
#先把数据列出来，这已经是有数据Node了
e4 = li.add_left('Sun')

e1 = li.append('Mon')
# li.headval = Node('Mon')
e2 = li.append('Tue')
e3 = li.append('Wed')
# 用指针连接节点，也就是设置指针
# e1.nextval = e2
# e2.nextval = e3
# li.append('Mon')
li.show()



##############
Sun
Mon
Tue
Wed
[Finished in 0.2s]
  • 插入末尾

这就是添加了一个新元素

i.append('某一新元素')
  • 在两个元素之间插入

同样地，将指针指向需要插入的新的元素就饿可以了。只需将前一个元素的指针指向插入的元素即可。举例：1--->2---->3 1--->2---->4----->3，原先2指向的是3，现在2指向的是插入元素4，然后由4指向3.

# 首先要有一个节点类
class Node:#(一个是数据、一个是指针，默认指向None)
    def __init__(self,dataval):
        self.dataval = dataval
        self.nextval = None 
class S_List:
    def __init__(self):
        #假设第一个数据是headval
        self.headval = None
    #定义一个函数--->在链表末尾添加一个新的node,这个node一定至少两个方面啊，
    #一是数据，而是指针
    def append(self,newdata):
        #只有数据
        Newdata = Node(newdata)
        # print(str(Newdata.nextval)+'&&&&&&&')
        if self.headval is None:
            self.headval = Newdata 
            # print(str(self.headval.dataval)+"******")
            return self.headval
        laste = self.headval
        # print(str(laste.dataval)+"******")
        #判断条件

        while laste.nextval:
            laste = laste.nextval
        laste.nextval = Newdata
        # print(str(laste.nextval.nextval)+'&&&&&&&')
    #插入链表开头
    # def add_left(self,newdata):
    # 	Newnode = Node(newdata)
    # 	if self.headval is None:
    #         self.headval = Newnode 
    #         # print(str(self.headval.dataval)+"******")
    #         return self.headval

    #添加节点
    def insert(self,middle,insert_node):
    	#首先判断有没有中间节点

    	#有中间节点
        Newdata = Node(insert_node)

        printval = self.headval
        while printval:
            # print(printval.dataval)
            if printval.dataval == middle:
                temp = printval.nextval
                printval.nextval = Newdata
                Newdata.nextval = temp


            printval = printval.nextval

    def show(self):
        printval = self.headval
        while printval:
            print(printval.dataval)
            printval = printval.nextval





li = S_List()
#先把数据列出来，这已经是有数据Node了
# e4 = li.insert(e2,'Sun')

e1 = li.append('1')
# li.headval = Node('Mon')
e2 = li.append('2')
e3 = li.append('3')
e4 = li.insert('2','5')
# 用指针连接节点，也就是设置指针
# e1.nextval = e2
# e2.nextval = e3
# li.append('Mon')
li.show()

删除链表元素

再简单说一下添加，添加呀，可以添加到开头，最后，中间某一位置。相应地，删除呢，可以删除开头、最后、中间某一位置。

  • 先来简单的吧。删除开头。就是把第一删除
#删除第一个元素
def remove_left(self):

    #将这个元素转化为Node
    # Remove_d = Node(Removedata)
    #判断是否有第一个元素
    if self.headval:
        self.headval = self.headval.nextval
  • 删除最后一个元素

这个操作其实不能那么简单的，为什么呢？第一，这是单链表，也就是只是指向一个方向；第二，我们可以很容易知道最后一个元素是哪个，但是却不能反向指向倒数第二个元素。

比如：我们可以知道最后一个元素的指针指向的是None。

prev = self.headval
#当跳出循环的时候，就表示找到最后一个元素。
while prev:
     prev = prev.nextval

那么，该怎么办呢？首先，我们需要知道，这个链表的长度，然后，依据长度找到倒数第二个元素，使得这个节点的指针指向的是`none`就可以了。

#确定链表长度
def link_len(self,len_link=0):
    #第一个节点
    prev = self.headval
    #确定链表长度-----len_link 
    while prev:
        len_link +=1
        prev = prev.nextval
        return len_link

删除最后一个元素：

def remove_final(self,length):
		prev = self.headval
		i = 0
		while prev is not None and  i<len_list-2:
			prev = prev.nextval
			i +=1
			print(str(i)+"^^^")
		prev.nextval = None
		return

总的代码：

# 首先要有一个节点类
class Node:#(一个是数据、一个是指针，默认指向None)
	def __init__(self,dataval):
		self.dataval = dataval
		self.nextval = None 
class S_List:
	def __init__(self):
		#假设第一个数据是headval
		self.headval = None
	#定义一个函数--->在链表末尾添加一个新的node,这个node一定至少两个方面啊，
	#一是数据，而是指针
	def append(self,newdata):
		#只有数据
		Newdata = Node(newdata)
		# print(str(Newdata.nextval)+'&&&&&&&')
		if self.headval is None:
			self.headval = Newdata 
			# print(str(self.headval.dataval)+"******")
			return self.headval
		laste = self.headval
		# print(str(laste.dataval)+"******")
		#判断条件

		while laste.nextval:
			laste = laste.nextval
		laste.nextval = Newdata
        # print(str(laste.nextval.nextval)+'&&&&&&&')
    #插入链表开头
    # def add_left(self,newdata):
    # 	Newnode = Node(newdata)
    # 	if self.headval is None:
    #         self.headval = Newnode 
    #         # print(str(self.headval.dataval)+"******")
    #         return self.headval

	#添加节点
	def insert(self,middle_node,insert_node):
		#首先判断有没有中间节点
		if not middle_node:
			print('The mentioned node is absent')
			return 

		#有中间节点
		Newdata = Node(insert_node)
		# middle_next = middle_node.nextval
		Newdata.nextval = middle_node.nextval
		middle_node.nextval = Newdata

	#删除第一个元素
	def len_L(self,len_link=0):
		#第一个节点
		prev = self.headval
		#将这个元素转化为Node
		# Remove_d = Node(Removedata)
		#判断是否有第一个元素,然后删除第一个元素
		# if self.headval:
		# 	self.headval = self.headval.nextval

		#确定链表长度-----len_link 
		while prev:
			len_link +=1
			prev = prev.nextval
		return len_link
	#删除最后一个元素

	def remove_final(self,length):
		prev = self.headval
		i = 0
		while prev is not None and  i<len_list-2:
			prev = prev.nextval
			i +=1
			print(str(i)+"^^^")
		prev.nextval = None
		return 



	def show(self):
		printval = self.headval
		while printval:
			print(printval.dataval)
			printval = printval.nextval



li = S_List()
#先把数据列出来，这已经是有数据Node了
# e4 = li.insert(e2,'Sun')

e1 = li.append('Mon')
# li.headval = Node('Mon')
e2 = li.append('Tue')
e3 = li.append('Wed')
e4 = li.insert(e1,'Sun')
len_list = (li.len_L())
print(len_list)
li.remove_final(length=len_list)
# 用指针连接节点，也就是设置指针
# e1.nextval = e2
# e2.nextval = e3
# li.append('Mon')
li.show()

####结果是
4
1^^^
2^^^
Mon
Sun
Tue
  • 现在我们来删除某任意节点。举例：1--->2--->3--->4 到 1---->2---->4
#删除任意位置节点
def remove_any(self,length,removekey):
    prev = self.headval
    i = 0
    while prev is not None and  i<(length-1-removekey-1):
        prev = prev.nextval
        i +=1
        print(str(i)+"^^^")
        prev.nextval = prev.nextval.nextval
        return

完整代码：

# 首先要有一个节点类
class Node:#(一个是数据、一个是指针，默认指向None)
	def __init__(self,dataval):
		self.dataval = dataval
		self.nextval = None 
class S_List:
	def __init__(self):
		#假设第一个数据是headval
		self.headval = None
	#定义一个函数--->在链表末尾添加一个新的node,这个node一定至少两个方面啊，
	#一是数据，而是指针
	def append(self,newdata):
		#只有数据
		Newdata = Node(newdata)
		# print(str(Newdata.nextval)+'&&&&&&&')
		if self.headval is None:
			self.headval = Newdata 
			# print(str(self.headval.dataval)+"******")
			return self.headval
		laste = self.headval
		# print(str(laste.dataval)+"******")
		#判断条件

		while laste.nextval:
			laste = laste.nextval
		laste.nextval = Newdata
        # print(str(laste.nextval.nextval)+'&&&&&&&')
    #插入链表开头
    # def add_left(self,newdata):
    # 	Newnode = Node(newdata)
    # 	if self.headval is None:
    #         self.headval = Newnode 
    #         # print(str(self.headval.dataval)+"******")
    #         return self.headval

	#添加节点
	def insert(self,middle_node,insert_node):
		#首先判断有没有中间节点
		if not middle_node:
			print('The mentioned node is absent')
			return 

		#有中间节点
		Newdata = Node(insert_node)
		# middle_next = middle_node.nextval
		Newdata.nextval = middle_node.nextval
		middle_node.nextval = Newdata

	#删除第一个元素
	def len_L(self,len_link=0):
		#第一个节点
		prev = self.headval
		#将这个元素转化为Node
		# Remove_d = Node(Removedata)
		#判断是否有第一个元素,然后删除第一个元素
		# if self.headval:
		# 	self.headval = self.headval.nextval

		#确定链表长度-----len_link 
		while prev:
			len_link +=1
			prev = prev.nextval
		return len_link
	#删除最后一个元素

	def remove_final(self,length):
		prev = self.headval
		i = 0
		while prev is not None and  i<len_list-2:
			prev = prev.nextval
			i +=1
			print(str(i)+"^^^")
		prev.nextval = None
		return 
	#删除任意位置节点
	def remove_any(self,length,removekey):
		prev = self.headval
		i = 0
		while prev is not None and  i<(length-1-removekey-1):
			prev = prev.nextval
			i +=1
			print(str(i)+"^^^")
		prev.nextval = prev.nextval.nextval
		return 



	def show(self):
		printval = self.headval
		while printval:
			print(printval.dataval)
			printval = printval.nextval



li = S_List()
#先把数据列出来，这已经是有数据Node了
# e4 = li.insert(e2,'Sun')

e1 = li.append('Mon')
# li.headval = Node('Mon')
e2 = li.append('Tue')
e3 = li.append('Wed')
e4 = li.insert(e1,'Sun')
len_list = (li.len_L())
li.remove_any(len_list, 2)
# print(len_list)
# li.remove_final(length=len_list)
# 用指针连接节点，也就是设置指针
# e1.nextval = e2
# e2.nextval = e3
# li.append('Mon')
li.show()

###结果
Mon
Tue
Wed
[Finished in 0.2s]

 

程序员小老九
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
KMP算法中next数组及nextval数组的求解
Q1178055813的博客
04-02 511
算法简介 该算法由Knuth，Morris以及Pratt三人共同提出，故又称Knuth-Morris-Pratt算法（简称KMP算法）。与暴力算法相比其优点主要是通过取消了主串的回溯来提高算法效率。 代码内容 # 人生苦短，我用python # 这里T表示副串，j，k为下标 # 由于next(0)=next(1)=0 (但为了方便设next(0)=-1) # next(2)=1 # 故这里仅考虑...
LeetBook——链表——02单链表——设计链表
qq_43269510的博客
06-16 155
设计链表的实现。 您可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：val 和 next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性 prev 以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。 在链表类中实现这些功能： get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。 addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第
求nextval数组值的简便方法
雨恨的专栏
03-08 4万+
求nextval数组值的第二种方法 模式串 a b a a b c a c next值 0 1 1 2 2 3 1 2 nextval值 0 1 0
python中sequence常用方法
ncst
06-19 4940
（1）序列类型函数 enumerate(), reversed(), sorted(), zip() （2）字符串类型方法 join(), strip(), replace(), split(), translate(),startswith()  其中translate()需要使用maketrans()方法： >>> z = str.maketrans(x,y) #in Python
python教程 序列(sequence)的概念
无可用
03-09 4368
python的序列 序列：就是有序存放的一组数据，这组数据由一个个独立的元素组成。 python中包含六种序列，分别是：列表、元组、字符串、Unicode字符串、buffer对象和 xrange 对象。其中最常用的是前三种。 python中的所有序列都具备以下几个特征： 1、元素有序存放，且每个元素的位置都有一个数字标识，第一个为0，第二个为1，以此类推，也可以从后往前数，最后一个是-1，倒数第二...
链表-使用Python实现链表数据结构.zip
03-13
本资源“链表-使用Python实现链表数据结构.zip”将详细介绍如何在Python中实现链表。 链表主要由节点（Node）组成，每个节点包含两部分：数据和指向下一个节点的引用。在Python中，我们可以用类来表示链表节点： `...
基于python的数据结构-链表Linked list
06-25
1. **单向链表**：每个节点只包含数据和指向下一个节点的指针。在Python中，我们可以用类来表示链表节点，如下所示： ```python class Node: def __init__(self, data=None): self.data = data self.next = None...
Python实现-无头单向非循环链表
12-22
无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的数据.（这个域叫数据域） ...
数据结构与算法-顺序表（链表篇）
09-09
在IT领域，数据结构与算法是计算机科学的基础，它们直接影响到程序的效率和设计。本资源专注于"顺序表"中的"链表"部分，这是一组相关数据元素的集合，其内部组织方式不同于传统的数组。链表不依赖于内存中的连续空间...
链表树-复合数据结构应用实例.zip
最新发布
06-17
链表有多种类型，如单向链表、双向链表和循环链表。在C/C++中，链表可以通过结构体和指针来实现；在Java中，可以使用LinkedList类；在Python中，可以使用内置的list或自定义类来模拟链表。学习链表的关键在于理解其...
KMP算法中Next与Nextval数组的计算(python实现)
迷航病患的博客
02-02 985
运行结果如下图所示： ```python ''' This program is aimed at calculating the next and nextval array of a given string. ''' def nextArray(string): ''' 计算next数组的函数 ''' nextA = [0] #初始化 for i in rang...
详解又详解KMP中的next和nextval的算法
markconca的博客
12-21 461
一、定义 KMP算法是一种改进的字符串匹配算法，由D.E.Knuth，J.H.Morris和V.R.Pratt同时发现，因此人们称它为克努特——莫里斯——普拉特操作（简称KMP算法）。 详细讲解参考这篇无敌博客：https://blog.csdn.net/nanami809/article/details/49367159...
kmp中next和nextval的区别
青竹梦
02-11 1万+
模式匹配。 kmp中next数组表示如果当前匹配不成功，匹配串移动到的位置，不考虑移动到的位置的数与当前位置数的关系。 kmp中nextval数组表示如果当前匹配不成功，匹配串移动到的位置，考虑移动到的位置的数与当前位置数的关系。 求next while(i<len) { if(j==-1||str[i]==str[j]) {
oracle中的CURRVAL和NEXTVAL用法
qianyiyiding的专栏
06-06 4万+
oracle中的CURRVAL和NEXTVAL用法1.什么是sequence？其作用是什么？ 在Oracle数据库中，什么是序列呢？其中的作用是什么呢？其实sequence是序列号生成器，可以为表中的行自动生成序列号，产生一组等间隔的数值(类型为数字)。其主要的用途是生成表的主键值，可以在插入语句中引用，在插入之前，获取序列号nextval值，然后进行插入。也可以通过查询检查当前值，或使序列增至
Python基础03 序列
weixin_34228617的博客
01-23 145
2019独角兽企业重金招聘Python工程师标准>>> ...
简单易懂next值nextval计算
机器人梦想家 Bing
08-23 2万+
读者注意！ 本篇文章可能存在问题，由于时间太久本人按照计算方法也算不出相同答案，如有慧眼请指点。 序号 1 2 3 4 5 字符串 a b a c a next值 0 1 1 2 1 next数组的求解方法是：第一位的next值为0，第二位的next值为1，后面求...
Next 值与 Nextval 值的计算
热门推荐
_IsWdZh
05-20 5万+
KMP算法对模式串求解其Next值和Nextval值的计算方法 Next值的计算 方法一 方法二 Nextval值的计算 模式串S = “abaabcac” ，求其 Next 数值序列： 1 2 3 4 5 6 7 8 a b a a b c a c Next值的计算 ...
kmp 的 next 数组和 nextval 数据求解
noname 博客
09-12 271
// 本篇仅为学习笔记 // 参考《大话数据结构》 1. next 数组 当 j=1，2 时，其 next 数组的值固定为 0，1 当 j>2 时，比较从模式串（匹配串）T 的第 1 位到 j-1 位的数字相同情况。若有 n 个相同，则 next 的值为 n+1 PS：其中匹配的时候，前后缀不能完全匹配。 2. nextval 数组 nextval 数组建立在已经求得 next 数组的基础...
7-122 单向链表的创建与输出
07-12
要创建一个单向链表，你可以定义一个节点类，每个节点包含一个数据项和指向下一个节点的指针。然后，通过不断创建新的节点并将其链接到链表的末尾来构建链表。以下是一个示例代码，演示了如何创建并输出一个单向链表...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值