Python与数据结构[0] -> 链表/LinkedList[0] -> 单链表与带表头单链表的 Python 实现

单链表 / Linked List

---

目录

1. 单链表
2. 带表头单链表

链表是一种基本的线性数据结构，在C语言中，这种数据结构通过指针实现，由于存储空间不要求连续性，因此插入和删除操作将变得十分快速。下面将利用Python来完成单链表的实现。

1 单链表

不带表头的单链表通常形式如下，

node_1 -> node_2 -> node_3 -> node_4

完整代码

 class Node:
     def __init__(self, val=None, nxt=None):
         self.value = val
         self.next = nxt

     def __str__(self):
         return str(self.value)

 class LinkedList:
     """
     Linked list:
             node_1 -> node_2 -> node_3 -> node_4
     """
     def __init__(self, iterable=()):
         self.header = None
         if iterable:
             self.init(iterable)

     def __str__(self):
         def _traversal(self):
             node = self.header
             while node and node.next:
                 yield node
                 node = node.next
             yield node
         return '->'.join(map(lambda x: str(x), _traversal(self)))

     def init(self, iterable=()):
         # Note: use empty tuple rather than list to init iterable
         if not iterable:
             return
         self.header = Node(iterable[0])     # header value
         node = self.header
         for i in iterable[1:]:              # add all node
             node.next = Node(i)
             node = node.next

     def show(self):
         print(self)

     @property
     def length(self):
         if self.header is None:
             return 0
         node = self.header      # node pointer points to header
         i = 1
         while node.next:
             node = node.next    # node pointer move to next
             i += 1
         return i

     @property
     def is_empty(self):
         return self.header is None

     def clear(self):
         self.__init__()
         # self.header = None

     def append(self, item):
         self.insert(item, self.length)

     def find(self, item):
         node = self.header
         while node.next and node.value != item:
             node = node.next
         if node.value == item:
             return node
         return None

     def find_previous(self, item):
         node = self.header
         while node.next and node.next.value != item:
             node = node.next
         if node.next and node.next.value == item:
             return node
         return None

     def delete(self, item):
         '''
         node_1 -- X --> node_2 -----> node_3
             \                    /
              \                  /
               ------------------
         '''
         prev = self.find_previous(item)
         if prev:
             prev.next = prev.next.next

     def insert(self, item, index):
         '''
                 ----> node_2 ---
                /                \
               /                  \
         node_1 -------  X  ---------> node_3

         '''
         if abs(index) > self.length:
             return
         if index < 0:
             self.insert(item, self.length+index+1)
             return
         elif index == 0:
             self.insert(self.header.value, 1)
             self.header.value = item
             return
         node = self.header
         i = 0
         while i < index-1:
             node = node.next
             i += 1
         n = node.next
         node.next = Node(item, n)

 def test(li):
     print('Show linked list:')
     li.show()

     print('\nInit linked list:')
     li.init([1, 2, 3, 4, 5, 6, 'xd', 8, 9])
     li.show()

     print('\nInsert element:')
     li.insert('xxd', -3)
     li.show()

     print('\nAppend element:')
     li.append('')
     li.show()

     e = 'xd'
     print('\nFind element:')
     x = li.find(e)
     print(x.value if x else x)
     print('\nFind previous element:')
     x = li.find_previous(e)
     print(x.value if x else x)

     print('\nDelete element:')
     li.delete('xd')
     li.show()

     print('\nFind element not exist:')
     x = li.find(e)
     print(x.value if x else x)

     print('\nInsert element to header:')
     li.insert('cc', 0)
     li.show()

     print('\nClear linked list:')
     li.clear()
     li.show()

     print('\nCurrent length: %s' % li.length)
     print('\nIs empty: %s' % li.is_empty)

 if __name__ == '__main__':
     test(LinkedList())

分段解释

首先，需要定义一个结点类（在C语言中则使用结构体进行定义），其中包括两个基本属性，当前值和下个结点。由于Python中无法使用类似C语言中的指针，因此只能通过变量的引用来实现类似指针操作的功能。为了更好的显示结点，这里重载了结点的内置函数__str__。

 class Node:
     def __init__(self, val=None, nxt=None):
         self.value = val
         self.next = nxt

     def __str__(self):
         return str(self.value)

接着，我们需要。定义一个链表类，并利用前面的结点来构建这个链表。链表类中包含了一个头结点属性，在初始化函数中，首先将头结点赋值None，类似于在C语言中将头结点指针指向NULL。初始化方法中定义了一个默认参数，使得链表可以在实例化的时候利用传入的可迭代对象进行链表生成。

 class LinkedList:
     """
     Linked list:
             node_1 -> node_2 -> node_3 -> node_4
     """
     def __init__(self, iterable=()):
         self.header = None
         if iterable:
             self.init(iterable)

重载链表的__str__方法，在显示链表的时候会对链表进行遍历，然后以更加清晰的方式显示在输出终端上。

     def __str__(self):
         def _traversal(self):
             node = self.header
             while node and node.next:
                 yield node
                 node = node.next
             yield node
         return '->'.join(map(lambda x: str(x), _traversal(self)))

定义链表的生成函数，函数中接收可迭代对象并生成新的链表。注意这里最好使用不可变的元组而不是可变的列表。

在生成时，首先将第一个元素作为头结点，然后依次将每个结点的next属性引用指向下一个结点。

     def init(self, iterable=()):
         # Note: use empty tuple rather than list to init iterable
         if not iterable:
             return
         self.header = Node(iterable[0])     # header value
         node = self.header
         for i in iterable[1:]:              # add all node
             node.next = Node(i)
             node = node.next

链表的show方法，由于已经重载了__str__方法，这里只需要print自身即可。

     def show(self):
         print(self)

链表的length属性方法，用于返回链表的长度，利用装饰器定义成属性方法，调用时遍历链表计算长度最后返回即可。

     @property
     def length(self):
         if self.header is None:
             return 0
         node = self.header      # node pointer points to header
         i = 1
         while node.next:
             node = node.next    # node pointer move to next
             i += 1
         return i

链表的is_empty属性方法，用于检测链表是否为空，只需要查看头结点是否为None即可。

     @property
     def is_empty(self):
         return self.header is None

链表的clear方法，用于清空链表，可以选择直接初始化链表或将链表的头结点指向None。

     def clear(self):
         self.__init__()
         # self.header = None

链表的append方法，用于在链表尾部添加一个元素结点，这里只要直接调用后面的insert方法并插入到链表长度的那个位置即可。

     def append(self, item):
         self.insert(item, self.length)

链表的find方法，用于在链表中查找并返回某个结点，查找时会从链表的头部开始，遍历查找，直到找到查找的值或遇到None，这里的find方法有两点需要注意：

1. 查找是依据元素的值进行查找，返回找到的第一个结点；
2. 这里的查找方法如果遇到有环链表将无法自行检测退出

最后返回查找到的结点或None。

     def find(self, item):
         node = self.header
         while node.next and node.value != item:
             node = node.next
         if node.value == item:
             return node
         return None

find_previous与find类似，返回查找结点的前一个结点。

     def find_previous(self, item):
         node = self.header
         while node.next and node.next.value != item:
             node = node.next
         if node.next and node.next.value == item:
             return node
         return None

delete方法用于删除结点，基本思路在于，找到需要删除结点node_2的前一个结点node_1，将前一个结点node_1的next指针指向删除结点的下一个结点node_3，从而惰性删除了这个结点。

查找前一个结点可以使用前面定义的find_previous方法。

     def delete(self, item):
         '''
         node_1 -- X --> node_2 -----> node_3
             \                    /
              \                  /
               ------------------
         '''
         prev = self.find_previous(item)
         if prev:
             prev.next = prev.next.next

insert方法用于向链表中插入一个结点，

基本思路在于，找到需要插入的位置前后的两个结点node_1和node_3，将node_1.next指向需要插入的结点node_2，再将node_2.next指向node_3，便完成了插入操作。

若插入的位置为头结点之前，则会替换原来的头结点为新插入的结点。

同时，这里的插入函数还支持index为负数的情况，类似于列表的负数索引。

     def insert(self, item, index):
         '''
                 ----> node_2 ---
                /                \
               /                  \
         node_1 -------  X  ---------> node_3

         '''
         if abs(index) > self.length:
             return
         if index < 0:
             self.insert(item, self.length+index+1)
             return
         elif index == 0:
             self.insert(self.header.value, 1)
             self.header.value = item
             return
         node = self.header
         i = 0
         while i < index-1:
             node = node.next
             i += 1
         n = node.next
         node.next = Node(item, n)

最后，定义一个测试函数用于测试链表的各种操作。

开始时显示空表

 def test(li):
     print('Show linked list:')
     li.show()

得到结果

Show linked list:
None

接着初始化链表元素

     print('\nInit linked list:')
     li.init([1, 2, 3, 4, 5, 6, 'xd', 8, 9])
     li.show()

得到结果

Init linked list:
1->2->3->4->5->6->xd->8->9

再向链表中插入元素

     print('\nInsert element:')
     li.insert('xxd', -3)
     li.show()

得到结果

Insert element:
1->2->3->4->5->6->xd->xxd->8->9

向链表末尾添加元素

     print('\nAppend element:')
     li.append('')
     li.show()

得到结果

Append element:
1->2->3->4->5->6->xd->xxd->8->9->10

查找元素

     e = 'xd'
     print('\nFind element:')
     x = li.find(e)
     print(x.value if x else x)
     print('\nFind previous element:')
     x = li.find_previous(e)
     print(x.value if x else x)

得到结果

Find element:
xd

Find previous element:
6

删除元素

     print('\nDelete element:')
     li.delete('xd')
     li.show()

得到结果

Delete element:
1->2->3->4->5->6->xxd->8->9->10

查找不存在的元素

     print('\nFind element not exist:')
     x = li.find(e)
     print(x.value if x else x)

得到结果

Find element not exist:
None

替换头结点

     print('\nInsert element to header:')
     li.insert('cc', 0)
     li.show()

得到结果

Insert element to header:
cc->1->2->3->4->5->6->xxd->8->9->10

清空链表并查看链表信息

     print('\nClear linked list:')
     li.clear()
     li.show()

     print('\nCurrent length: %s' % li.length)
     print('\nIs empty: %s' % li.is_empty)

得到结果

Clear linked list:
None

Current length: 0

Is empty: True

2 带表头单链表

这种单链表带有一个标志结点，通常被称为表头或哑结点，表头通常位于位置0处，通常不会被改变。

Linked list with dummy header node:
       Header -> node_1 -> node_2 -> node_3

带表头的单链表在实现时与不带表头的单链表类似，因此可以继承前面的单链表类来派生出一个带表头单链表类，其中需要进行修改和重载的方法主要有生成链表、判断链表为空和插入链表这几个方法。

 from linked_list import Node, LinkedList, test

 class LinkedListDummyHeader(LinkedList):
     """
     Linked list with dummy header node:
             Header -> node_1 -> node_2 -> node_3
     """
     def __init__(self, iterable=()):
         self.header = Node('Header', None)
         if iterable:
             self.init(iterable)

     def init(self, iterable=()):
         if not iterable:
             return
         node = self.header
         for i in iterable:
             node.next = Node(i)
             node = node.next

     @property
     def is_empty(self):
         return self.header.next is None
         # if self.length == 1:
         #     return True
         # return False

     def insert(self, item, index):
         if index == 0:
             return
         super(LinkedListDummyHeader, self).insert(item, index)

 if __name__ == '__main__':
     test(LinkedListDummyHeader())

__init__方法：

初始化时头结点不再指向None，而是指向表头。

init方法：

由于有表头的存在，因此创建初始链表的方法首先需要建立一个表头，再将所有元素依次加入链表中。

is_empty方法：

由于表头的存在，此时判断是否为空则可以根据表头指向结点是否为空，或链表长度是否为1来进行。

insert方法：

此处需要修改的地方在于当插入点为表头时，则应该直接返回或引发异常，无法修改表头。

最后利用单链表的测试函数进行测试得到结果

Show linked list:
Header

Init linked list:
Header->1->2->3->4->5->6->xd->8->9

Insert element:
Header->1->2->3->4->5->6->xd->xxd->8->9

Append element:
Header->1->2->3->4->5->6->xd->xxd->8->9->10

Find element:
xd

Find previous element:
6

Delete element:
Header->1->2->3->4->5->6->xxd->8->9->10

Find element not exist:
None

Insert element to header:
Header->1->2->3->4->5->6->xxd->8->9->10

Clear linked list:
Header

Current length: 1

Is empty: True