数据结构与算法-链表（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
  
    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

    def isempty(self):                        # 判断是否空
        p = self.head
        if p == None:
            return True
        else:
            return False

    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是很常见的，再进行后续处理。

# 循环方法
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前加一个结点通常比较舒服。其次是交换时定位到两个结点前一个的位置即可。最后注意的是交换两个相邻结点的情况要特殊处理。

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.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