数据结构之链表（Linked list）

1, 无序链表（Unordered linked list）

　　链表是有若干个数据节点依次链接成的数据结构，如下图所示，每一个数据节点包括包括数据和一个指向下一节点的指针。（python中的list就是由链表来实现的）

　　　　　　

　　无序链表操作：

Llist = UnorderedList()   #创建无序链表
add(item)                    #向链表中加入item（首部加入）
remove(item)              #从链表中移除item
search(item)                #从链表中搜索item
pop()                          #从链表末尾移除节点
append()                     #从链表末尾加入节点
pop(pos)                     #从链表指定位置移除节点
insert(pos, item)           #从链表指定位置加入节点
index(item)                  #返回item在链表中的位置
size()                           #返回链表大小
isEmpty()                      #返回链表是否为空

　　python实现无序链表

　　　　定义了Node类和UnorderedList类，代码如下：

#coding:utf-8

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

    def getNext(self):
        return self.next

    def setData(self,newData):
        self.data=newData

    def setNext(self,newNext):
        self.next = newNext

class UnorderedList(object):
    def __init__(self):
        self.head=None

    def add(self,item):
        temp = Node(item)
        temp.setNext(self.head)
        self.head=temp

    def remove(self,item): #未考虑item不存在链表中的情况，考虑时参见下面有序列表中remove方法
        previous = None
        current = self.head
        found = False
        if current:
            while not found:
                if current.getData()==item:
                    found = True
                else:
                    previous = current
                    current = current.getNext()
            if previous==None:
                self.head = current.getNext()
            else:
                previous.setNext(current.getNext())
        return found

    def search(self,item):
        current = self.head
        found = False
        while current!=None and (not found):
            if current.getData()==item:
                found = True
                return current
            else:
                current = current.getNext()
        return found

    def pop(self):
        previous = None
        current = self.head
        if current:
            while current.getNext()!=None:
                previous = current
                current = current.getNext()
            if previous==None:
                self.head=None
            else:
                previous.setNext(None)
        else:
            raise IndexError("pop from empty unorderedList")
        return current.getData()

    def append(self,item):
        temp = Node(item)
        current = self.head
        previous = None
        while current!=None:
            previous = current
            current = current.getNext()
        if previous==None:
            self.head=temp
        else:
            previous.setNext(temp)

    def index(self,item):
        count = 0
        current =self.head
        while current and (current.getData()!=item):
            count = count+1
            current = current.getNext()
        if count and (count<self.size()):
            return count
        else:
            raise ValueError("%s is not in UnorderedList"%item)
    
    def size(self):
        count = 0
        current = self.head
        while current!=None:
            count += 1
            current = current.getNext()
        return count

    def isEmpty(self):
        return self.head==None

u = UnorderedList()
u.append(3)
u.append(2)
u.append(6)
#print u.index(6), u.index(7)
print u.size(),u.pop()
print u.size(),u.pop()
print u.size(),u.pop()

　　　链表排序

class ListNode(object):
    def __init__(self,data,next=None):
        self.data = data
        self.next = next
    def traverse(self):
        temp = self
        while temp!=None:
            print temp.data
            temp = temp.next

l1 = ListNode(1,ListNode(56,ListNode(8,ListNode(20,ListNode(10,ListNode(12))))))
l2 = ListNode(5,ListNode(9,ListNode(7,ListNode(10,ListNode(12)))))

利用归并排序对链表排序
def sort_list(head):
    if head==None or head.next==None:
        return head
    left = head
    mid = get_mid(head)
    right = mid.next
    mid.next=None
    return merge(sort_list(left),sort_list(right))
    
def merge(left, right):
    node = ListNode(0)
    temp = node
    while left and right:
        if left.data>=right.data:
            temp.next = right
            right = right.next
        else:
            temp.next = left
            left = left.next
        temp = temp.next
    if left:
        temp.next = left
    if right:
        temp.next = right
    return node.next
    
def get_mid(node):
    if node==None:
        return node
    slow = node
    fast = node
    while fast.next and fast.next.next:
        slow = slow.next
        fast = fast.next.next
    return slow
l1.traverse()
sort_list(l1)
l1.traverse()
print("*"*20)
l2.traverse()
sort_list(l2)
l2.traverse()

归并排序