python数据结构与算法——链表

具体的数据结构可以参考下面的这两篇博客：

python 数据结构之单链表的实现：

http://www.cnblogs.com/yupeng/p/3413763.html

python 数据结构之双向链表的实现：

http://www.cnblogs.com/yupeng/p/3413800.html

我这里只实现了单链表的类型，代码也相对精简一点：

先构造关于节点的类：

 class Node:
     def __init__(self,data=None,next=None):
         self.data = data
         self.next = next

节点只有两个成员，一个是节点的数据，一个是链表的键值，用于查找其中的元素，另一个是指向下一个结点的引用。

通过结点，下面实现了链表的类，提供了在链表的两种插入和删除方法

 class Chain:
     def __init__(self):
         self.head = None
         self.tail = None
         self.count = 0

     def append(self,node):
         """ 在链表末尾追加元素 """
         self.count += 1
         if self.head == None:
             self.head = node
             self.tail = self.head
         else:
             self.tail.next = node
             self.tail = self.tail.next

     def __repr__(self):
         """ 重构：对链表进行输出 """
         temp = self.head
         cstr = ""
         for i in range(self.count-1):
             cstr += str(temp.data)+' -> '
             temp = temp.next
         cstr += str(temp.data)
         return cstr

     def insert(self,n):
         """ 在一个有序链表中插入元素
             输入 元素的data值
         """
         self.count += 1
         t = self.head   # 暂存头指针，并非其引用
         p = Node(n)
         if t.data > n:
             p.next = t      # 可以写成 p.next = self.head
             self.head = p   # 不能写成 t=p
         else:
             while t!=None:
                 if t.next==None or t.next.data > n:
                     p.next = t.next     # 保存后面的节点
                     t.next = p
                     break
                 t = t.next

     def delete(self,data):
         """ 删除链表中指定元素
             输入 原素的data值
             备注： 如果有多个同样的元素，一次只删除一个
         """
         t = self.head           # 从头结点开始查找，用于缓存当前结点的父结点
         if self.head.data==data:
             self.head = self.head.next
             self.count -= 1
             return True

         while t.next!=None:
             if t.next.data==data:    # 找到目标结点为下一个结点
                 # 意味着必然存在下下个结点
                 t.next = t.next.next # 将当前结点的下一个结点直向下下个结点
                 self.count -= 1
                 return True
             else:
                 t = t.next    # 继续找下下个结点
         else:
             # while-else结构，当while循环没有碰到break时，调用else语句
             # 找不到数据
             return False

测试结果：

if __name__=="__main__":
    L = [1,2,3,4,5]
    chain = Chain()
    for i in L:
        n = Node(i)
        chain.append(n)

    chain.insert(0)
    print chain
>>> 0 -> 1 -> 2 -> 3 -> 4 -> 5

    chain.delete(3)     # 删除中间数据
    print chain
>>> 0 -> 1 -> 2 -> 4 -> 5

    chain.delete(0)     # 删除头数据
    print chain
>>> 1 -> 2 -> 4 -> 5

    chain.delete(5)     # 删除尾数据
    print chain
>>> 1 -> 2 -> 4