python数据结构之链表——基本操作实现

前言：

这是python实现数据结构的第一篇，不是讲python內建的元组、字典那些数据结构，而是基于python的链表、队列、栈、二叉树等数据结构的实现。
基于C++和JAVA的数据结构实现俯拾皆是，然而python的实现还鲜见于博客。对于初学python并立足于python的学习者们需要熟悉python实现数据结构的那一套理论。
数据结构以链表的实现为基础，这是十分常见的数据结构，从链表开始，逐渐深入，实现每一种的代码并解析网上常见的相关算法题目。

链表

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而顺序表相应的时间复杂度分别是O(logn)和O(1)。特点：使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。基本操作：包括创建链表（初始化）、获取长度、插入、查找、删除、遍历，以及略复杂的链表逆序和结点交换。下面将这些操作一一实现并作出解释。class ListNode(object):
def __init__(self,data,p = None):
self.data = data
self.next = p

class Linklist(object):
def __init__(self):
self.head = None
def set(self):                        # 初始建立
print('input:')
data = input()
if data != "":
self.head = ListNode(int(data))
p = self.head
else:
print('over!')
return
while 1:
data = input()
if data != "":
p.next = ListNode(int(data))
p = p.next
else:
print('over!')
break
@property
def show(self):                        # 遍历链表
print('链表元素如下：')
p = self.head
if p == None:
print('Empty!')
return
while p:
print(p.data,end=',')
p = p.next
print('over!')
return
@property
def isempty(self):                        # 判断是否空
p = self.head
if p == None:
return True
else:
return False
@property
def length(self):                        # 获取长度
p = self.head
l = 0
while p:
l += 1
p = p.next
return l
def insert(self,data,pos):                # 数据插入
if self.isempty and pos != 1:
raise Exception('wrong position!')
p = self.head
if pos == 1:
self.head = ListNode(data)
self.head.next = p
n = 2
while n < pos and p.next != None:
p = p.next
n += 1
if n == pos:
tmp = p.next
p.next = ListNode(data)
p = p.next
p.next = tmp
elif n < pos:
raise Exception('wrong position!')

def delete(self,pos):                        # 删除操作
p = self.head
# 假设位置信息有效
if pos == 1:
return self.head.next
for i in range(pos - 2):
p = p.next
p.next = p.next.next以上是一些基本操作，注意以下几点:
1.基本操作的关键是学会链表的遍历和定位，每个操作参数表如何、返回值如何都可根据实际问题相应改变，做题时一般不是作为一个链表class的方法。
2.next结点默认为None，遍历时while p即可，比较方便；
3.最重要一点是，大多数问题，都需要单独、特别处理头结点，需要养成良好习惯。一般题目给出的参数都是head即链表的头，先判断head==None是很常见的，再进行后续处理。
下面是链表的逆序问题，参考博客单链表反转python实现，一个循环方法，一个递归方法，关键是理解其原理，然后可以很自然得写出来，链表的逆转是很重要的基本功。下图是对循环方法的图解，我认为理解并熟练运用这一方法即可~



# 循环方法
def reverse(head):
if head == None or head.next == None:
return head
pre = None
cur = head
h = head
while cur:
h = cur
tmp = cur.next
cur.next = pre
pre = cur
cur = tmp
return h

def recurse(head,newhead):        # 递归方法，head为原链表的头结点，newhead为反转后链表的头结点
if head is None:              # 使用时需先初始化newhead
return
if head.next is None:
newhead = head
else :
newhead = recurse(head.next,newhead)
head.next.next = head
head.next = None
return newhead

最为复杂的是链表结点的交换问题，但是原理并不复杂，由于面对链表头这玩意，在head前加一个结点通常比较舒服。其次是交换时定位到两个结点前一个的位置即可。最后注意的是交换两个相邻结点的情况要特殊处理。代码如下，是交换第m个和第n个结点，亲测可用，供大家交流学习。def swap(head,m,n):
# 认为m,n 有效
newhead = ListNode(-1) # 0 结点
newhead.next = head
p = newhead
for i in range(m-1): # 定位到m-1 处
p = p.next
if m + 1 == n: # 二者相邻时
q = p.next
tmp = q.next.next
p.next = q.next
p.next
9f45
.next = q
q.next = tmp
return newhead.next
else:
q = p
for i in range(n-m): # 一般情况时，定位到n-1 处
q = q.next
tmp = q.next.next
nodem = p.next
p.next = q.next
p.next.next = nodem.next
q.next = nodem
q.next.next = tmp
return newhead.next这些是单链表，还有一种双向链表。优点是方便我们前向寻找结点，使一些问题更简单；而缺点是当我们熟悉了单链表的那一套理论后，很可能不会使用这玩意儿。双向链表占用更多空间，在删除、插入、逆序等各种操作时都会额外增加问题。如果遇到这方面的问题还是要认真研究一番。class LinkedList():
def __init__(self, value):
self.value = value
# 前结点
self.before = None
# 后结点
self.behind = None
这就是链表的基本理论和方法，需要亲自实现一番才好，然后到LeetCode去刷一些相关题目巩固所学（关注本人其他博客）。链表是其他数据结构的基础，在刚接触数据结构时需要格外重视~