头指针与头结点的理解,链表带有头结点与不带头结点的python实现

对于数据结构的头结点、头指针问题,一直都有点不太清楚理解。现对其中涉及的概念与如何使用python语言创建链表(带有头结点与不带头结点)进行解释。

一、基本概念

假设我们将对数组array[a1,a2,a3]创建链表结果,两种存储方式如下图所示:

概念小结:

1)对一个链表结构,头指针是必须存在的,其实就是链表名称,指向的是链表的第一个节点的指针(可以是头结点也可以是首元节点,看实现方式)。

2)当链表头结点存在的时候,它是是链表的第一个节点,指向首元节点(首元节点存储数据a1)。头结点的数据域可以不存储任何信息,设置为None.

二、代码实现

''''结点类LNode——有无头节点该部分代码不变'''
class LNode:
    # 结点结构
    def __init__(self,data=None,next_=None):
        self.data = data
        self.next = next_

2.1 创建无头结点的链表实现

''''单链表对象LList的类——无头节点'''
class LList(object):
    # 定义一个空表,_head命名作为对象的内部表示,不希望外部使用
    def __init__(self):
        self._head = None
        
     # 后端操作,在链表的最后插上元素
    def append(self,data):
        p = self._head
        # 当链表是空表的时候
        if self._head is None:
            self._head = LNode(data)
            return
        # 注意这是p.next不是空,这样p才是最后存在的结点
        while p.next is not None:
            p = p.next
        # 先遍历到最后元素,这里需要last_p得到返回的是引用类型
        p.next = LNode(data)
    
    # 遍历链表结点——有无头结点这个代码一样
    def traverse(self):
        p = self._head
        while p is not None:
            print(p.data,'#')
            p = p.next
        # 最后p是None值
# 创建无头结点的链表
array = [1,2,3]
l = LList()
for item in array:
    l.append(item)
# 遍历输出
l.traverse()    

'''
最后遍历节点输出结果为:
1 #
2 #
3 #
'''

2.2 创建带有头结点的链表实现

''''单链表对象HeadNodeLList的类——带有头节点'''
class HeadNodeLList(object):
    # 定义一个空表,_head命名作为对象的内部表示,不希望外部使用
    def __init__(self):
        self._head = None
        
     # 后端操作,在链表的最后插上元素
    def append(self,data):
        p = self._head
        # 当链表是空表的时候
        if self._head is None:
            # 创建头结点——这是区别于不带头结点的地方
            self._head = LNode()
            self._head.next = LNode(data)
            return
        # 注意这是p.next不是空,这样p才是最后存在的结点
        while p.next is not None:
            p = p.next
        # 先遍历到最后元素,这里需要last_p得到返回的是引用类型
        p.next = LNode(data)
    
    # 遍历链表结点——有无头结点这个代码一样
    def traverse(self):
        p = self._head
        while p is not None:
            print(p.data,'#')
            p = p.next
        # 最后p是None值
# 创建有头结点的链表
array = [1,2,3]
head_node_l = HeadNodeLList()
for item in array:
    head_node_l.append(item)
# 遍历输出
head_node_l.traverse()  

'''
带有头节点的链表遍历节点输出结果为:
None #
1 #
2 #
3 #
'''

 

  • 4
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,我来回答你的问题。 构造不带头结点的循环链表可以按照如下步骤进行: 1. 定义一个 Node 类,用于表示链表中的节点。每个节点需要包含两个属性:值和指向下一个节点的指针。 2. 定义一个 CircularLinkedList 类,用于表示循环链表。需要包含两个属性:链表的长度和指向链表第一个节点的指针。需要实现如下方法: - `__init__(self, values: List[int])`: 构造函数,接收一个列表作为输入,将其中的元素转化为链表节点,并将它们组成循环链表。 - `__len__(self) -> int`: 返回链表长度。 - `__str__(self) -> str`: 返回链表的字符串表示。 - `__iter__(self) -> Iterator`: 实现迭代器,用于遍历链表中的节点。 - `remove(self, node: Node) -> Node`: 从链表中删除一个节点,并返回被删除的节点。 - `josephus(self, k: int) -> List[int]`: 实现约瑟夫环,返回出列的节点的值的列表。 下面是一个示例代码,实现了上述功能: ```python from typing import List, Iterator class Node: def __init__(self, value: int): self.value = value self.next = None class CircularLinkedList: def __init__(self, values: List[int]): self.head = None self.length = 0 for value in values: self.append(value) if self.head: self.tail.next = self.head def append(self, value: int): node = Node(value) if not self.head: self.head = node else: self.tail.next = node self.tail = node self.length += 1 def __len__(self) -> int: return self.length def __str__(self) -> str: values = [str(node.value) for node in self] return "->".join(values) def __iter__(self) -> Iterator: node = self.head while node: yield node node = node.next def remove(self, node: Node) -> Node: if self.length == 1: self.head = None self.tail = None else: prev_node = self.head while prev_node.next != node: prev_node = prev_node.next prev_node.next = node.next if node == self.head: self.head = node.next elif node == self.tail: self.tail = prev_node self.length -= 1 node.next = None return node def josephus(self, k: int) -> List[int]: out = [] node = self.head while len(self) > 0: for i in range(k - 1): node = node.next out.append(node.value) node = self.remove(node).next return out ``` 在上面的代码中,我们首先定义了一个 Node 类,用于表示链表中的节点。然后,我们定义了一个 CircularLinkedList 类,用于表示循环链表。在构造函数中,我们遍历输入列表中的元素,将它们转化为链表节点,并将它们组成循环链表。在实现约瑟夫环的方法 `josephus` 中,我们使用一个 while 循环,不断地从链表中删除第 k 个节点,直到链表为空为止,并将每个被删除的节点的值添加到输出列表中。 希望我的回答能够解决你的问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值