python 实现线性链表（单链表）--增加合并链表算法

初学python，拿数据结构中的线性链表存储结构练练手，理论比较简单，直接上代码。

#!/usr/bin/python

# Author: Hui
# Date: 2017-10-13

# 结点类，
class Node:

def __init__(self, data):
    self.data = data            # 数据域
    self.next = None            # 指针域

def get_data(self):
    return self.data

# 链表类
class List:

def __init__(self, head):
    self.head = head            # 默认初始化头结点

def is_empty(self):         # 空链表判断
    return self.get_len() == 0

def get_len(self):          # 返回链表长度
    length = 0
    temp = self.head
    while temp is not None:
        length += 1
        temp = temp.next
    return length

def append(self, node):         # 追加结点（链表尾部追加）
    temp = self.head
    while temp.next is not None:
        temp = temp.next
    temp.next = node

def delete(self, index):           # 删除结点
    if index < 1 or index > self.get_len():
        print "给定位置不合理"
        return
    if index == 1:
        self.head = self.head.next
        return
    temp = self.head
    cur_pos = 0
    while temp is not None:
        cur_pos += 1
        if cur_pos == index-1:
            temp.next = temp.next.next
        temp = temp.next

def insert(self, pos, node):         # 插入结点
    if pos < 1 or pos > self.get_len():
        print "插入结点位置不合理..."
        return
    temp = self.head
    cur_pos = 0
    while temp is not Node:
        cur_pos += 1
        if cur_pos == pos-1:
            node.next = temp.next
            temp.next =node
            break
        temp = temp.next

def reverse(self, head):          # 反转链表
    if head is None and head.next is None:
        return head
    pre = head
    cur = head.next
    while cur is not None:
        temp = cur.next
        cur.next = pre
        pre = cur
        cur = temp
    head.next = None
    return pre

def print_list(self, head):           # 打印链表
    init_data = []
    while head is not None:
        init_data.append(head.get_data())
        head = head.next
    return init_data


if __name__ == '__main__':

    head = Node("head")
    list = List(head)
    print '初始化头结点：\t', list.print_list(head)

    for i in range(1, 10):
        node = Node(i)
        list.append(node)
    print '链表添加元素：\t', list.print_list(head)

    print '链表是否空：\t', list.is_empty()

    print '链表长度：\t', list.get_len()

    list.delete(9)
    print '删除第9个元素:\t',list.print_list(head)

    node = Node("insert")
    list.insert(3, node)
    print '第3个位置插入‘insert’字符串 :\t', list.print_list(head)

    head = list.reverse(head)
    print '链表反转：', list.print_list(head)

执行结果：
初始化头结点： [‘head’]
链表添加元素： [‘head’, 1, 2, 3, 4, 5, 6, 7, 8, 9]
链表是否空： False
链表长度： 10
删除第9个元素: [‘head’, 1, 2, 3, 4, 5, 6, 7, 9]
第3个位置插入‘insert’字符串 : [‘head’, 1, ‘insert’, 2, 3, 4, 5, 6, 7, 9]
链表反转： [9, 7, 6, 5, 4, 3, 2, ‘insert’, 1, ‘head’]

————————-附加算法：要求合并两个有序链表，要求和并后依然有序—————————-

headA = Node(0)
headB = Node(0)

listA = List(headA)
listB = List(headB)
for i in range(10, 40, 5):
    node = Node(i)
    listA.append(node)
for i in range(5, 30, 6):
    node = Node(i)
    listB.append(node)
print "链表A：", listA.print_list(headA), "链表B：", listB.print_list(headB)

def merge_list(headA, headB):  # 合并两个有序链表，要求合并后仍然有序

    if headA.get_data() > headB.get_data():
       headC = Node(headB.get_data())
       headC.next = Node(headA.get_data())
    else:
        headC = Node(headA.get_data())
        headC.next = Node(headB.get_data())

    temp = headC.next
    while headA.next is not None and headB.next is not None:
        if headA.next.get_data() > headB.next.get_data():
            temp.next = Node(headB.next.get_data())
            headB = headB.next
        else:
            temp.next = Node(headA.next.get_data())
            headA = headA.next
        temp = temp.next

    temp.next = headA.next if headA.next else headB.next  #把剩余非空链表，链接到C中
    return headC
after_merge_head = merge_list(headA, headB)
listC = List(after_merge_head)
print "合并后：", listC.print_list(after_merge_head)

执行结果：
链表A： [0, 10, 15, 20, 25, 30, 35] 链表B： [0, 5, 11, 17, 23, 29]
合并后： [0, 0, 5, 10, 11, 15, 17, 20, 23, 25, 29, 25, 30, 35]

——————————-附加完———————————————————————————————–