python数据结构 —— 链表（中）

于 2024-05-23 01:08:23 发布
阅读量707 收藏 18
点赞数 14
文章标签： 数据结构 python 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77774241/article/details/139119771
版权

上篇进行了初识链表、构造链表、打印链表、append、pop，链接如下：
python数据结构 —— 链表（上）
本篇将介绍链表的prepend、pop first 、get和set

6.prepend —— 将结点添加到链表前面

首先应该讨论链表的长度是否为零，如果链表的长度为零，则相当于创建一个链表。如果链表长度不为零，则需要一个head结点，通过head的由原来的头结点移动到新结点的过程完成新结点的添加。

def prepend(self,value):
      new_node = Node(value)
      if self.length == 0:
            self.head = new_node 
            self.tail = new_node 
      else:
            new_node.next = self.head 
            self.head = new_node 
      self.length += 1
      return True

将链表长度不为零的过程可视化如下：
prepend_01
prepend_02

  • 下面的代码是一个完整过程示例：
class Node:
      def __init__(self,value):
            self.value = value 
            self.next = None 
            
class LinkedList:
      def __init__(self,value):
            new_node = Node(value)
            self.head = new_node 
            self.tail = new_node 
            self.length = 1 
      def print_list(self):
            temp = self.head 
            while temp is not None:
                  print(temp.value)
                  temp = temp.next 
      def append(self,value):
            new_node = Node(value)
            if self.length == 0:
                  self.head = new_node
                  self.tail = new_node 
            else:
                  self.tail.next = new_node 
                  self.tail = new_node 
            self.length += 1
      def prepend(self,value):
            new_node = Node(value)
            if self.length == 0:
                  self.head = new_node 
                  self.tail = new_node 
            else:
                  new_node.next = self.head 
                  self.head = new_node 
            self.length += 1
            return True    

my_linked_list = LinkedList(2)
my_linked_list.append(3)
my_linked_list.prepend(1)
my_linked_list.print_list()

运行的输出结果如下：

1
2
3

7.pop first —— 删除第一个节点

涉及到删除的内容，我们需要考虑链表的长度。（1）链表长度为0，谈不上任何删除操作；（2）链表长度不为零，利用head和temp新结点，利用.next = None的操作把结点之间的连接箭头断开。

def pop_first(self):
      if self.length == 0:
            return None
      temp = self.head 
      self.head = self.head.next 
      temp.next = None 
      self.length -= 1 
      if self.length == 0:
            self.tail = None 
      return temp

如果链表长度不为零，将pop first的过程可视化
pop_first01
利用self.head = self.head.next一句，将head结点往后移
pop_first02
利用temp.next = None将两个节点之间的箭头断掉，完成删除第一个结点过程
pop_first03

  • 下面的代码是一个完整过程示例：
class Node:
      def __init__(self,value):
            self.value = value 
            self.next = None 
            
class LinkedList:
      def __init__(self,value):
            new_node = Node(value)
            self.head = new_node 
            self.tail = new_node 
            self.length = 1 
      def print_list(self):
            temp = self.head 
            while temp is not None:
                  print(temp.value)
                  temp = temp.next 
      def append(self,value):
            new_node = Node(value)
            if self.length == 0:
                  self.head = new_node
                  self.tail = new_node 
            else:
                  self.tail.next = new_node 
                  self.tail = new_node 
            self.length += 1
      def pop_first(self):
            if self.length == 0:
                  return None
            temp = self.head 
            self.head = self.head.next 
            temp.next = None 
            self.length -= 1 
            if self.length == 0:
                  self.tail = None 
            return temp.value    
      
my_linked_list = LinkedList(2)
my_linked_list.append(3)

# 2 items - return 2 node 
print(my_linked_list.pop_first())
# 1 items - return 1 nodes
print(my_linked_list.pop_first())
# 0 items - return none
print(my_linked_list.pop_first())

输出结果如下：

2
3
None

8.get —— 通过索引找到结点的值

本实现需要引入index索引，索引的数值从0开始。索引最大值=长度-1，所以索引值不能为负，也不可以大于等于长度值

def get(self,index):
      if index < 0 or index >= self.length:
            return None 
      temp = self.head
      for _ in range(index):
            temp = temp.next 
            return temp

上面代码中的_是一个常见的变量名，通常用作占位符。

  • 补充

  • range()是一个内置函数，用于生成一系列连续的整数，语法如下：
    range(start,end,stop) 中start指的是计数起始值，默认是0；stop指的是计数结束值，但不包括stop；step是步长，默认为1，不可以为0。

  • 使用range()函数的时候，如果只有一个参数，就表示end，从0开始；如果有两个参数，就表示start和end；如果有三个参数，最后一个就表示步长。注意其接受的必须是整数。

  • 下面的代码是一个完整过程示例：

class Node:
      def __init__(self,value):
            self.value = value 
            self.next = None 
            
class LinkedList:
      def __init__(self,value):
            new_node = Node(value)
            self.head = new_node 
            self.tail = new_node 
            self.length = 1 
      def print_list(self):
            temp = self.head 
            while temp is not None:
                  print(temp.value)
                  temp = temp.next 
      def append(self,value):
            new_node = Node(value)
            if self.length == 0:
                  self.head = new_node
                  self.tail = new_node 
            else:
                  self.tail.next = new_node 
                  self.tail = new_node 
            self.length += 1
      def get(self,index):
            if index < 0 or index >= self.length:
                  return None 
            temp = self.head
            for _ in range(index):
                  temp = temp.next 
            return temp.value
            
my_linked_list = LinkedList(0)
my_linked_list.append(1)
my_linked_list.append(2)
my_linked_list.append(3)

# my_linked_list.print_list()

print(my_linked_list.get(2))
print(my_linked_list.get(0))

运行后的结果如下：

2
0

如果要找索引为2的结点的值，将过程可视化如下：
get_01
get_02
get_03
其实上面的过程相当于temp结点移动“index”值多少步。如上例所示，index为2，那我相当于移动2步，找到的结点值为2。

9.set —— 设置结点的值

要设置结点的值，首先应该先找到结点所在的位置——>索引，所以会调用上面所提及的get函数，将我所要更改的结点的值赋给temp结点，即可完成设置。

def set_value(self,index,value):
      temp = self.get(index)
      if temp:
            temp.value = value 
            return True 
      return False
  • 下面的代码是一个完整过程示例：
class Node:
     def __init__(self,value):
           self.value = value 
           self.next = None 
           
class LinkedList:
     def __init__(self,value):
           new_node = Node(value)
           self.head = new_node 
           self.tail = new_node 
           self.length = 1 
     def print_list(self):
           temp = self.head 
           while temp is not None:
                 print(temp.value)
                 temp = temp.next 
     def append(self,value):
           new_node = Node(value)
           if self.length == 0:
                 self.head = new_node
                 self.tail = new_node 
           else:
                 self.tail.next = new_node 
                 self.tail = new_node 
           self.length += 1
     def get(self,index):
           if index < 0 or index >= self.length:
                 return None 
           temp = self.head
           for _ in range(index):
                 temp = temp.next 
           return temp
     def set_value(self,index,value):
           temp = self.get(index)
           if temp:
                 temp.value = value 
                 return True 
           return False  
           
my_linked_list = LinkedList(11)
my_linked_list.append(3)
my_linked_list.append(23)
my_linked_list.append(7)

my_linked_list.print_list()

my_linked_list.set_value(1,4)

print("after set -----------")
my_linked_list.print_list()

运行后的结果如下：

11
3
23
7
after set -----------
11
4
23
7
newer c
关注
  • 14
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值