链表详解(python实现)

一、 定义见百度百科链表

链表由表头和节点组成,节点分为数据域和指针域,数据域中存贮数据元素,指针域存储下个结点的地址

二、单链表实现逻辑
  1. 创建节点类Node和链表类Linklist,Linklist类中包含head属性,head的值为0或Node对象,Node类中包含value属性存储数据,next属性存储下个节点的地址(Node对象)
  2. 循环节点从head开始取next属性,直到next=0为止,返回当前对象
  3. 添加节点时调用循环方法返回最后一个节点对象,把返回节点的next改为当前Node对象,如当前没有节点,则Linklist实例的head属性修改为当前Node对象
  4. 删除节点时把前一个节点的next属性修改为后一个节点的Node对象,如果当前节点是最后一个对象
三、单链表代码实现
class Node:
    def __init__(self,value,node = 0):
        self.value = value
        self.next = node

class LinkList:
    
    def __init__(self, value=0,*args):
        self.lenth = 0
        #创建表头head
        self.head = 0 if value == 0 else Node(value)
        #如果初始化实例时传入多个参数,循环加入链表
        p = self.head
        for i in [*args]:
            node = Node(i)
            p.next = node
            p = p.next
    def append(self,value):
        if self.head == 0:
            self.head = Node(value)
        else:    
            self.iternodes().next = Node(value)
    
    def iternodes(self):
        p = self.head
        while p:
            print(p.value)
            if not p.next:
                return p
            p = p.next
四、双链表实现
  • 对比单链表,Node对象增加了before属性记录前一节点对象,同时增加insert、pop等方法
  • 利用python的特殊方法,把Linklist类构造成一个类似list的类,可以使用len()方法,可迭代
#创建Node类
class Node:
    def __init__(self, value, before=0, node=0):
        self.value = value
        self.next = node
        self.before = before
        
#创建链表类
class LinkList:
    def __init__(self, value=0,*args):
        self.lenth = 0
        #创建表头head
        self.head = 0 if value == 0 else Node(value)
        #如果初始化实例时传入多个参数,循环加入链表
        if self.head != 0:
            self.lenth += 1
            p = self.head
            for i in [*args]:
                node = Node(i)
                p.next = node
                node.before = p
                p = p.next
                self.lenth += 1
                
    #append方法,判断表头是否为空,每次执行lenth属性值+1
    def append(self, value):
        if self.head == 0:
            self.head = Node(value)
            self.lenth += 1
        else:
            p = Node(value)
            cur = self.iternodes()
            cur.next = p
            p.before = cur
            self.lenth += 1
            
    #insert方法(后插),是否表头特殊处理,每次执行lenth属性值+1
    def instert(self, value, index):
        if self.head == 0:
            self.append(value)
        else:
            p = Node(value)
            prv = self.iternodes(index)
            if prv.__dict__.get('head'):
                p.before = prv.head
                prv.head.next = p
                if prv.head.next != 0:
                    prv.head.next.before = p
                    p.next = prv.head.next             
            else:
               
                p.before = prv
                if prv.next != 0:
                    prv.next.before = p
                p.next = prv.next
                prv.next = p
                
            self.lenth += 1
    
    #遍历方法,每次从表头开始
    def iternodes(self, index=None):
        if index is not None:
            if index > self.lenth:
                raise Exception("索引超界")
            p = self.head
            i = 0
            while p:
                if i == index:
                    return p
                p = p.next
                i += 1
        else:
            p = self.head
            while p:
                if not p.next:
                    return p
                p = p.next
    
    #删除方法,删除指定索引的值,表头特殊处理,每次执行lenth属性值-1
    def pop(self, index=None):
        if self.lenth == 0:
            return 'LinkList is empty'
        if index is None:
            if self.lenth == 1:
                self.head = 0
                self.lenth -= 1
                return
            if self.iternodes().before == 0:
                self.iternodes().value = 0
            else:
                self.iternodes().before.next = 0    
        elif index == 0:
            if self.iternodes(index).next == 0:
                self.head = 0
            else:
                self.head.next.before = 0
                self.head = self.head.next
        else:
            self.iternodes(index).before.next = self.iternodes(index).next
            self.iternodes(index).next.before = self.iternodes(index).before
        self.lenth -= 1
        
    def __len__(self):
        return self.lenth

    def __iter__(self):
        yield  from (self.iternodes(i) for i in range(self.lenth))
        
  • 5
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值