python实现单向链表详解

本文研究的主要是Python中实现单向链表的相关内容,具体如下。

什么是链表

链表顾名思义就是~链

链表是一种动态数据结构,他的特点是用一组任意的存储单元存放数据元素。链表中每一个元素成为“结点”,每一个结点都是由数据域和指针域组成的。跟数组不同链表不用预先定义大小,而且硬件支持的话可以无限扩展。

链表与数组的不同点:

数组需要预先定义大小,无法适应数据动态地增减,数据小于定义的长度会浪费内存,数据超过预定义的长度无法插入。而链表是动态增删数据,可以随意增加。

数组适用于获取元素的操作,直接get索引即可,链表对于获取元素比较麻烦需要从头一直寻找,但是适用与增删,直接修改节点的指向即可,但是对于数组就比较麻烦了,例如[1,2,3,4]需要在下标为1的位置插入-2,则需要将[2,3,4]后移,赋值ls[1]=-2

数组从栈中分配空间, 对于程序员方便快速,但自由度小。链表从堆中分配空间, 自由度大但申请管理比较麻烦.

链表基本方法实现(Python)

1. 初始化链表

"""节点类"""

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

def __init__(self):
  """初始化链表"""
  self.head = None

2. 获取链表长度

def __len__(self):
  pre = self.head
  length = 0
  while pre:
    length += 1
    pre = pre.nex
  return length

3. 追加节点

追加节点还是比较简单的,如果head节点不存在,则当前节点为head节点,否则的话找到尾节点,将尾节点的next指向当前节点(可以添加head和tail两个节点,就不用递归寻找尾节点了)

"""追加节点"""

def append(self, data):
  """
  1.head 为none :head-->node
  2.tail.nex-->node
  :param data:
  :return:
  """
  node = Node(data)
  if self.head is None:
    self.head = node
  else:
    pre = self.head
    while pre.nex:
      pre = pre.nex
    pre.nex = node

4. 获取节点

获取节点也是比较容易的,无非就是判断index值的正负

def get(self, index):
  """
  :param index:
  :return:
  """
  index = index if index >= 0 else len(self) + index
  if len(self) < index or index < 0:
    return None
  pre = self.head
  while index:
    pre = pre.nex
    index -= 1
  return pre

5. 设置节点

找到当前节点赋值即可

"""设置节点"""

def set(self, index, data):
  node = self.get(index)
  if node:
    node.data = data
  return node

6. 插入节点

插入节点需要找到插入节点的前一个节点pre_node(索引index的正负,前一节点不同,需要判断一下),然后将pre_node.nex指向当前节点。同时将当前节点的nex指向pre_node.nex.nex

"""插入节点"""

def insert(self, index, data):
  """
  1.index 插入节点位置包括正负数
  2.找到index-1-->pre_node的节点
  3.pre_node.next-->node
   node.next-->pre_node.next.next
  4.head
  :param index:
  :param data:
  :return:
  """
  node = Node(data)
  if abs(index + 1) > len(self):
    return False
  index = index if index >= 0 else len(self) + index + 1
  if index == 0:
    node.nex = self.head
    self.head = node
  else:
    pre = self.get(index - 1)
    if pre:
      nex = pre.nex
      pre.nex = node
      node.nex = nex
    else:
      return False
  return node

7. 删除节点

删除节点,也要区分一下索引的正负。找到当前节点的前一个节点pre_node和后一个节点next_node,将pre_node.nex–>next_node即可

"""删除某个元素"""

def delete(self, index):
  f = index if index > 0 else abs(index + 1)
  if len(self) <= f:
    return False
  pre = self.head
  index = index if index >= 0 else len(self) + index
  prep = None
  while index:
    prep = pre
    pre = pre.nex
    index -= 1
  if not prep:
    self.head = pre.nex
  else:
    prep.nex = pre.nex
  return pre.data

8. 反转链表

反转链表的实现有多种方式,比较简单的就是生成一个新的链表--》可以用数组存储所有节点让后倒序生成新的链表
在这里用下面这种方式生产:
反转链表就是将node.nex–>pre_node 递归实现即可,然后让tail赋值为head

"""反转链表"""

def __reversed__(self):
  """
  1.pre-->next 转变为 next-->pre
  2.pre 若是head 则把 pre.nex --> None
  3.tail-->self.head
  :return:
  """

  def reverse(pre_node, node):
    if pre_node is self.head:
      pre_node.nex = None
    if node:
      next_node = node.nex
      node.nex = pre_node
      return reverse(node, next_node)
    else:
      self.head = pre_node

  return reverse(self.head, self.head.nex)

9. 清空链表

将头赋为空就好

"""清空链表"""

def clear(self):
  self.head = None

总结

以上就是本文关于python实现单向链表详解的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

(0)

相关推荐

  • Python单向链表和双向链表原理与用法实例详解

    本文实例讲述了Python单向链表和双向链表原理与用法.分享给大家供大家参考,具体如下: 链表是一种数据结构,链表在循环遍历的时候效率不高,但是在插入和删除时优势比较大. 链表由一个个节点组成. 单向链表的节点分为两个部分:存储的对象和对下一个节点的引用.注意是指向下一个节点. 而双向链表区别于单向链表的是它是由三个部分组成:存储的对象.对下一个节点的引用.对上一个节点的引用,可以实现双向遍历. 单向列表的结构如下图: head是头节点,tail是尾节点,每个节点由Data存储对象和Next对下

  • Python单链表简单实现代码

    本文实例讲述了Python单链表简单实现代码.分享给大家供大家参考,具体如下: 用Python模拟一下单链表,比较简单,初学者可以参考参考 #coding:utf-8 class Node(object): def __init__(self, data): self.data = data self.next = None class NodeList(object): def __init__(self, node): self.head = node self.head.next = No

  • Python实现针对给定单链表删除指定节点的方法

    本文实例讲述了Python实现针对给定单链表删除指定节点的方法.分享给大家供大家参考,具体如下: 题目: 初始化定义一个单链表,删除指定节点,输出链表 下面是具体的实现: #!usr/bin/env python #encoding:utf-8 ''''' __Author__:沂水寒城 功能:给定一个单链表删除指定节点 ''' class Node(object): ''''' 节点类 ''' def __init__(self,data): self.num=data self.next=N

  • python实现获取单向链表倒数第k个结点的值示例

    本文实例讲述了python实现获取单向链表倒数第k个结点的值.分享给大家供大家参考,具体如下: #初始化链表的结点 class Node(): def __init__(self,item): self.item = item self.next = None #传入头结点,获取整个链表的长度 def length(headNode): if headNode == None: return None count = 0 currentNode =headNode #尝试了一下带有环的链表,计算

  • python实现反转部分单向链表

    题目: 给定一个单链表的头指针 head, 以及两个整数 a 和 b,在单链表中反转 linked_list[a-b] 的结点,然后返回整个链表的头指针. 例如: 单链表[1000, 5, 12, 100, 45, 'cecil', 999], a = 4, b = 6, 返回的链表是[1000, 5, 12, 100, 999, 'cecil', 45],也就是说, a 和 b分别为索引值.如果a 和 b 超过了索引范围就返回错误. 代码: 我写的不够简洁,比较繁琐,但是能跑通,繁琐的原因在于

  • Python数据结构与算法之链表定义与用法实例详解【单链表、循环链表】

    本文实例讲述了Python数据结构与算法之链表定义与用法.分享给大家供大家参考,具体如下: 本文将为大家讲解: (1)从链表节点的定义开始,以类的方式,面向对象的思想进行链表的设计 (2)链表类插入和删除等成员函数实现时需要考虑的边界条件, prepend(头部插入).pop(头部删除).append(尾部插入).pop_last(尾部删除) 2.1 插入: 空链表 链表长度为1 插入到末尾 2.2 删除 空链表 链表长度为1 删除末尾元素 (3)从单链表到单链表的一众变体: 带尾节点的单链表

  • python数据结构链表之单向链表(实例讲解)

    单向链表 单向链表也叫单链表,是链表中最简单的一种形式,它的每个节点包含两个域,一个信息域(元素域)和一个链接域.这个链接指向链表中的下一个节点,而最后一个节点的链接域则指向一个空值. 表元素域elem用来存放具体的数据. 链接域next用来存放下一个节点的位置(python中的标识) 变量p指向链表的头节点(首节点)的位置,从p出发能找到表中的任意节点. 节点实现 class Node(object): """单链表的结点""" def __i

  • 浅谈Python单向链表的实现

    链表由一系列不必在内存中相连的结构构成,这些对象按线性顺序排序.每个结构含有表元素和指向后继元素的指针.最后一个单元的指针指向NULL.为了方便链表的删除与插入操作,可以为链表添加一个表头. 删除操作可以通过修改一个指针来实现. 插入操作需要执行两次指针调整. 1. 单向链表的实现 1.1 Node实现 每个Node分为两部分.一部分含有链表的元素,可以称为数据域:另一部分为一指针,指向下一个Node. class Node(): __slots__=['_item','_next'] #限定N

  • Python数据结构与算法之列表(链表,linked list)简单实现

    Python 中的 list 并不是我们传统(计算机科学)意义上的列表,这也是其 append 操作会比 insert 操作效率高的原因.传统列表--通常也叫作链表(linked list)--通常是由一系列节点(node)来实现的,其每一个节点(尾节点除外)都持有一个指向下一个节点的引用. 其简单实现: class Node: def __init__(value, next=None): self.value = value self.next = next 接下来,我们就可使用链表的结构来

  • python实现单链表中删除倒数第K个节点的方法

    本文实例为大家分享了python实现单链表中删除倒数第K个节点的具体代码,供大家参考,具体内容如下 题目: 给定一个链表,删除其中倒数第k个节点. 代码: class LinkedListAlgorithms(object): def __init__(self): pass def rm_last_kth_node(self, k, linked_list): # 删除倒数第 K 个节点,针对单链表的 if linked_list.is_empty(): print 'The given li

  • python判断单向链表是否包括环,若包含则计算环入口的节点实例分析

    本文实例讲述了python判断单向链表是否包括环,若包含则计算环入口的节点.分享给大家供大家参考,具体如下: 关于数据结构相关的面试题,经常会问到链表中是否存在环结构的判断,下图就是存在环结构的链表. 那么如何判断链表中是否存在环呢,下面解法的思路是采用快慢指针: 两个指向头节点的指针,fast和slow,一起从头结点开始往后遍历,fast每次移动两个节点,slow每次移动一个节点, 这样,如果存在环结构,那么fast指针在不断绕环过程中,肯定会追上slow指针. # -*- coding:ut

  • python单向链表的基本实现与使用方法【定义、遍历、添加、删除、查找等】

    本文实例讲述了python单向链表的基本实现与使用方法.分享给大家供大家参考,具体如下: # -*- coding:utf-8 -*- #! python3 class Node(): def __init__(self,item): #初始化这个节点,值和下一个指向 self.item = item self.next = None class SingleLinklist(): def __init__(self): #初始化这个单链表的头指针为空 self._head = None def

随机推荐