用python构建链表问题详解

目录

 背景

Python中的链表实现

通用接口实现

单向链表

双向链表

环形链表

---

 背景

链表是一种数据存储结构。他的物理地址是非连续的，右逻辑顺序是通过链表中的指针链接次序实现的。如下图所示，节点1有一个指向节点2的指针、节点2有一个指向节点3的指针。

Python中的链表实现

通用接口实现

常见的链表分为单向链表，双向链表，环形链表。但无论何种链表形式，他都具有一个指向下一个链表的指针。如下代码所表示：

class Node(object):
    def __init__(self, value):
        '''
        value ： int 值
        next ：Node 下一个节点指针
        '''
        self.value = value
        self.next = None
        
    def __repr__(self):
        '''
        打印方法
        '''
        return f'Node: value={self.value}'
    
    def __str__(self):
        '''
        打印方法
        '''
        return f'Node: value={self.value}'
    
    def __eq__(self, other):
        '''
        一致性方法
        '''
        return self.value == other.value

我们将针对以上三种链表形式，实现add（从头部加入一个节点）、append（从尾部加入一个节点）、delete（删除指定节点）、length（链表长度）和printLink（遍历并打印链表）这几种方法

class Link(object):
    def __init__(self, head=None):
        if head:
            self._head = head
        else:
            self._head = None
        
    def add(self, node):
        '''
        从头部加入一个节点
        '''
        pass
    
    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        pass
    
    def delete(self, node):
        '''
        删除指定节点
        '''
        pass
    
    def length(self):
        '''
        链表长度
        '''
        pass
    
    def printLink(self):
        '''
        遍历并打印链表
        '''
        pass

单向链表

单向链表是最为简单的链表。他只有一个指向下一个节点的指针。

class SingleNode(Node):
    def __init__(self, value):
        super(SingleNode, self).__init__(value)

单向链表的初始化：

单项链表有三个变量

self._head 为头节点

self._tail 为尾节点

self.length 为当前长度

class SingleLink(Link):
    def __init__(self, head=None):
        '''
        _head : SingleNode, 头节点
        _tail : SingleNode, 尾节点
        length : 链表长度
        '''
        super(SingleLink, self).__init__(head)
        if self._head is None:
            self._tail = self._head
            self.length = 0
        else:
            self._tail = self._head
            self.length = 1
            while self._tail.next is not None:
                self.length += 1
                self._tail = self._tail.next

add方法（从头部加入一个节点），如果是个空链表，则头节点和尾节点都是这个新加入的节点。

如果是非空链表，则新节点的next指针指向头节点，新节点为新的头部节点

    def add(self, node):
        '''
        从头部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            node.next = self._head
            self._head = node

append（从尾部加入一个节点）,如果是个空链表，则头节点和尾节点都是这个新加入的节点。

如果是非空链表，则尾部节点的next指针指向新节点，新节点为新的尾部节点

    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            self._tail.next = node
            self._tail = node

delete（删除指定节点），链表删除比较复杂的方法，需要分几类情况分别考虑：

1、链表为空，什么都不用做，直接返回

2、被删节点是头部节点：

        将头部节点指向其下一个节点。

        如果只有两个节点，说明删除了头结点后，尾巴节点和头节点重合。如下图：

 3、被删节点是尾部节点：

        将被删节点的上一个节点设定为尾部节点

     

 4、其他普遍类型

        将被删节点上一个节点的next指针指向被删节点的next

    def delete(self, node):
        '''
        删除指定节点
        '''
        if self._head is None:
            return 
        if self._head == node:
            self._head = self._head.next
            if self.length <= 2:
                self._tail = self._head
            self.length -= 1
        else:
            cur = self._head
            while cur is not None and cur.next is not None:
                if cur.next == node:
                    self.length -= 1
                    if self._tail == node:
                        self._tail = cur
                    cur.next = cur.next.next
                    return 
                cur = cur.next

printLink（遍历并打印链表） ，从头部节点开始打印，知道指针为空

def printLink(self):
        '''
        遍历并打印链表
        '''
        cur = self._head
        while cur is not None:
            print(cur)
            cur = cur.next
    
                    

代码汇总：

class Node(object):
    def __init__(self, value):
        '''
        value ： int 值
        next ：Node 下一个节点指针
        '''
        self.value = value
        self.next = None
        
    def __repr__(self):
        '''
        打印方法
        '''
        return f'Node: value={self.value}'
    
    def __str__(self):
        '''
        打印方法
        '''
        return f'Node: value={self.value}'
    
    def __eq__(self, other):
        '''
        一致性方法
        '''
        return self.value == other.value
        
class Link(object):
    def __init__(self, head=None):
        if head:
            self._head = head
        else:
            self._head = None
        
    def add(self, node):
        '''
        从头部加入一个节点
        '''
        pass
    
    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        pass
    
    def delete(self, node):
        '''
        删除指定节点
        '''
        pass
    
    def length(self):
        '''
        链表长度
        '''
        pass
    
    def printLink(self):
        '''
        遍历并打印链表
        '''
        pass
    
   
class SingleNode(Node):
    def __init__(self, value):
        super(SingleNode, self).__init__(value)
        
class SingleLink(Link):
    def __init__(self, head=None):
        '''
        _head : SingleNode, 头节点
        _tail : SingleNode, 尾节点
        length : 链表长度
        '''
        super(SingleLink, self).__init__(head)
        if self._head is None:
            self._tail = self._head
            self.length = 0
        else:
            self._tail = self._head
            self.length = 1
            while self._tail.next is not None:
                self.length += 1
                self._tail = self._tail.next
            
    def add(self, node):
        '''
        从头部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            node.next = self._head
            self._head = node
            
            
    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            self._tail.next = node
            self._tail = node
            
    def delete(self, node):
        '''
        删除指定节点
        '''
        if self._head is None:
            return 
        if self._head == node:
            self._head = self._head.next
            if self.length <= 2:
                self._tail = self._head
            self.length -= 1
        else:
            cur = self._head
            while cur is not None and cur.next is not None:
                if cur.next == node:
                    self.length -= 1
                    if self._tail == node:
                        self._tail = cur
                    cur.next = cur.next.next
                    return 
                cur = cur.next
    
    def printLink(self):
        '''
        遍历并打印链表
        '''
        cur = self._head
        while cur is not None:
            print(cur)
            cur = cur.next
    
                    

双向链表

与单项链表节点不同的上，双向链表有两个指针，分别指向上一个位置和下一个位置。与单向链表相比，双向链表获取节点更为遍历，但损失了更多的储存空间。

# 双向链表
class DoubleNode(Node):
    def __init__(self, value):
        '''
        value ： int 值
        next ：DoubleNode 下一个节点指针
        prev ：DoubleNode 上一个节点指针
        '''
        super(DoubleNode, self).__init__(value)
        self.prev = None

 双向链表的初始化：

 双向链表有三个变量

self._head 为头节点

self._tail 为尾节点

self.length 为当前长度

class DoubleLink(Link):
    def __init__(self, head=None):
        '''
        _head : SingleNode, 头节点
        _tail : SingleNode, 尾节点
        length : 双向链表的长度
        '''
        super(DoubleLink, self).__init__(head)
        if self._head is None:
            self._tail = self._head
            self.length = 0
        else:
            self._tail = self._head
            self.length = 1
            while self._tail.next is not None:
                self.length += 1
                self._tail = self._tail.next

add方法（从头部加入一个节点），如果是个空链表，则头节点和尾节点都是这个新加入的节点。

如果是非空链表，则新节点的next指针指向头节点，头节点的prev指针指向新节点，并且把新节点设定为新的头部节点

    def add(self, node):
        '''
        从头部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            node.next = self._head
            self._head.prev = node
            self._head = node
            

append（从尾部加入一个节点）,如果是个空链表，则头节点和尾节点都是这个新加入的节点。

如果是非空链表，则尾部节点的next指针指向新节点，新节点的prev指针指向尾部节点，最后把新节点设为新的尾部节点

    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            self._tail.next = node
            node.prev = self._tail
            self._tail = node

delete（删除指定节点），链表删除比较复杂的方法，需要分几类情况分别考虑：

1、链表为空，什么都不用做，直接返回

2、被删节点是头部节点：

        将头部节点指向其下一个节点。将现在的头节点的prev指针设为空

        如果只有两个节点，说明删除了头结点后，尾巴节点和头节点重合。如下图：

 3、被删节点是尾部节点：

        将被删节点的上一个节点设定为尾部节点

 4、其他普遍类型

        将被删节点上一个节点的next指针指向被删节点的next

        将被删节点下一个节点的prev指针指向被删节点的prev

    def delete(self, node):
        '''
        删除指定节点
        '''
        if self._head is None:
            return 
        if self._head == node:
            self._head = self._head.next
            self._head.prev = None
            if self.length <= 2:
                self._tail = self._head
            self.length -= 1
        else:
            cur = self._head
            while cur is not None:
                if cur == node:
                    self.length -= 1
                    if self._tail == node:
                        self._tail = cur.prev
                        
                    prevNode = cur.prev
                    nextNode = cur.next
                    if prevNode:
                        prevNode.next = nextNode
                    if nextNode:
                        nextNode.prev = prevNode
                cur = cur.next
                

printLink（遍历并打印链表） ，和单项链表无区别，从头部节点开始打印，知道指针为空

    def printLink(self):
        '''
        遍历并打印链表
        '''
        cur = self._head
        while cur is not None:
            print(cur)
            cur = cur.next

reversePrintLink（倒叙打印链表），从尾部开始往前打印，直到指针为空

    def reversePrintLink(self):
        cur = self._tail
        while cur is not None:
            print(cur)
            cur = cur.prev

双向链表代码汇总

# 双向链表
class DoubleNode(Node):
    def __init__(self, value):
        '''
        value ： int 值
        next ：DoubleNode 下一个节点指针
        prev ：DoubleNode 上一个节点指针
        '''
        super(DoubleNode, self).__init__(value)
        self.prev = None


class DoubleLink(Link):
    def __init__(self, head=None):
        '''
        _head : SingleNode, 头节点
        _tail : SingleNode, 尾节点
        length : 双向链表的长度
        '''
        super(DoubleLink, self).__init__(head)
        if self._head is None:
            self._tail = self._head
            self.length = 0
        else:
            self._tail = self._head
            self.length = 1
            while self._tail.next is not None:
                self.length += 1
                self._tail = self._tail.next
            
    def add(self, node):
        '''
        从头部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            node.next = self._head
            self._head.prev = node
            self._head = node
            
            
    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            self._tail.next = node
            node.prev = self._tail
            self._tail = node
            
    def delete(self, node):
        '''
        删除指定节点
        '''
        if self._head is None:
            return 
        if self._head == node:
            self._head = self._head.next
            self._head.prev = None
            if self.length <= 2:
                self._tail = self._head
            self.length -= 1
        else:
            cur = self._head
            while cur is not None:
                if cur == node:
                    self.length -= 1
                    if self._tail == node:
                        self._tail = cur.prev
                        
                    prevNode = cur.prev
                    nextNode = cur.next
                    if prevNode:
                        prevNode.next = nextNode
                    if nextNode:
                        nextNode.prev = prevNode
                cur = cur.next
                
    def length(self):
        '''
        链表长度
        '''
        return self.length
    
    def printLink(self):
        '''
        遍历并打印链表
        '''
        cur = self._head
        while cur is not None:
            print(cur)
            cur = cur.next
    
    def reversePrintLink(self):
        cur = self._tail
        while cur is not None:
            print(cur)
            cur = cur.prev

环形链表

环形链表顾名思义，是呈现环状循环链表，他的末尾节点指向头节点，循环往复

环形链表节点和单项链表一样，只有一个指向下一个节点的next指针

# 环状链表
class CycleNode(Node):
    def __init__(self, value):
        super(CycleNode, self).__init__(value)
        

 环形链表的初始化：

 环形链表有三个变量

self._head 为头节点

self._tail 为尾节点

self.length 为当前长度

class CycleLink(Link):
    def __init__(self):
        super(CycleLink, self).__init__()
        self._head = self._head
        self._tail = self._head
        self.length = 0

add方法（从头部加入一个节点），如果是个空链表，则头节点和尾节点都是这个新加入的节点。

如果是非空链表，则新节点的next指针指向头节点，并且把新节点设定为新的头部节点，把尾节点的next指针指向新的头节点

    def add(self, node):
        '''
        从头部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            node.next = self._head
            self._head = node
            self._tail.next = self._head
            

append（从尾部加入一个节点）,如果是个空链表，则头节点和尾节点都是这个新加入的节点。

如果是非空链表，则尾部节点的next指针指向新节点，新节点设为新的尾部节点。尾部节点的next指针指向头节点

    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            self._tail.next = node
            self._tail = node
            self._tail.next =self._head

delete（删除指定节点），链表删除比较复杂的方法，需要分几类情况分别考虑：

1、链表为空，什么都不用做，直接返回

2、被删节点是头部节点：

        将头部节点指向其下一个节点。将现在的头节点的prev指针设为空

        如果只有两个节点，说明删除了头结点后，尾巴节点和头节点重合。如下图：

 3、被删节点是尾部节点：

        将被删节点的上一个节点设定为尾部节点

 4、其他普遍类型

        将被删节点上一个节点的next指针指向被删节点的next

    def delete(self, node):
        '''
        删除指定节点
        '''
        if self._head is None:
            return 
        if self._head == node:
            self._head = self._head.next
            if self.length <= 2:
                self._tail = self._head
            self.length -= 1
            self._tail.next = self._head
        else:
            cur = self._head
            while cur is not None and cur.next is not None:
                if cur.next == node:
                    self.length -= 1
                    if self._tail == node:
                        self._tail = cur
                    cur.next = cur.next.next
                    self._tail.next = self._head
                    return 
                cur = cur.next

printLink（遍历并打印链表） ，和单项链表无区别，从头部节点开始打印，下一个节点为头节点

    
    def printLink(self):
        '''
        遍历并打印链表
        '''
        if self._head is None:
            return 
        cur = self._head
        while cur.next != self._head:
            print(cur)
            cur = cur.next
        print(cur)
    

环形链表代码汇总：

# 环状链表
class CycleNode(Node):
    def __init__(self, value):
        super(CycleNode, self).__init__(value)
        

class CycleLink(Link):
    def __init__(self):
        super(CycleLink, self).__init__()
        self._head = self._head
        self._tail = self._head
        self.length = 0

            
    def add(self, node):
        '''
        从头部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            node.next = self._head
            self._head = node
            self._tail.next = self._head
            
            
    def append(self, node):
        '''
        从尾部加入一个节点
        '''
        self.length += 1
        if self._head is None:
            self._head = node
            self._tail = node
            return
        else:
            self._tail.next = node
            self._tail = node
            self._tail.next =self._head
            
    def delete(self, node):
        '''
        删除指定节点
        '''
        if self._head is None:
            return 
        if self._head == node:
            self._head = self._head.next
            if self.length <= 2:
                self._tail = self._head
            self.length -= 1
            self._tail.next = self._head
        else:
            cur = self._head
            while cur is not None and cur.next is not None:
                if cur.next == node:
                    self.length -= 1
                    if self._tail == node:
                        self._tail = cur
                    cur.next = cur.next.next
                    self._tail.next = self._head
                    return 
                cur = cur.next
                
    def length(self):
        '''
        链表长度
        '''
        return self.length
    
    def printLink(self):
        '''
        遍历并打印链表
        '''
        if self._head is None:
            return 
        cur = self._head
        while cur.next != self._head:
            print(cur)
            cur = cur.next
        print(cur)