数据结构之链表（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()
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_list2(head): if head==None: return head temp = head import heapq hq = [] while temp: heapq.heappush(hq,temp.data) temp = temp.next head = ListNode(heapq.heappop(hq)) prev = head while hq: current = ListNode(heapq.heappop(hq)) prev.next = current prev = prev.next l1.traverse() sort_list2(l1) l1.traverse() print("*"*20) l2.traverse() sort_list2(l2) l2.traverse()
链表倒转
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 reverse(head): prev = head cur = head.next prev.next = None while cur: temp = cur.next cur.next = prev prev = cur cur = temp return prev l1.traverse() r = reverse(l1) print("="*30) r.traverse()
#链表翻转。给出一个链表和一个数k，比如，链表为1→2→3→4→5→6，k=2，则翻转后2→1→6→5→4→3，若k=3，翻转后3→2→1→6→5→4，若k=4，翻转后4→3→2→1→6→5，用程序实现。 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)))))) def reverse(head): prev = head cur = head.next prev.next = None while cur: temp = cur.next cur.next = prev prev = cur cur = temp return prev,head def reverse_linkedlist(head,k): temp = head for i in range(k-1): temp = temp.next if temp==None: return None mid = temp.next temp.next=None head1,end1 = reverse(head) head2,end2 = reverse(mid) end1.next = head2 return head1 l2= reverse_linkedlist(l1,3) l2.traverse()
判断链表是否有环，并返回环入口点，计算环长度
（1）题目描述：输入一个单向链表，判断链表是否有环？
分析：通过两个指针，分别从链表的头节点出发，一个每次向后移动一步，另一个移动两步，两个指针移动速度不一样，如果存在环，那么两个指针一定会在环里相遇。
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(31,ListNode(26,ListNode(18,ListNode(32)))) #在链表中构造环路 def cycle_list(l1): first = l1 temp = first for i in range(3): #向后移动三次，即将20作为入环节点 temp = temp.next while first.next: first = first.next first.next = temp return l1 l3 = cycle_list(l1) #l3.traverse() #检查是否存在环路 def check_cycle(head): slow = fast = head while fast!=None and fast.next!=None: fast = fast.next.next slow = slow.next if slow is fast: return True return False print(check_cycle(l2)) #False print(check_cycle(l3)) #True
（2）题目描述：输入一个单向链表，判断链表是否有环。如果链表存在环，如何找到环的入口点？
解题思路： 由上题可知，按照 p2 每次两步，p1 每次一步的方式走，发现 p2 和 p1 重合，确定了单向链表有环路了。接下来，让p2回到链表的头部，重新走，每次步长不是走2了，而是走1，那么当 p1 和 p2 再次相遇的时候，就是环路的入口了。
为什么？：假定起点到环入口点的距离为 a，p1 和 p2 的相交点M与环入口点的距离为b，环路的周长为L，当 p1 和 p2 第一次相遇的时候，假定 p1 走了 n 步。那么有：
p1走的路径： a+b ＝ n；
p2走的路径： a+b+k*L = 2*n； p2 比 p1 多走了k圈环路，总路程是p1的2倍
根据上述公式可以得到 k*L=a+b=n显然，如果从相遇点M开始，p1 再走 n 步的话，还可以再回到相遇点，同时p2从头开始走的话，经过n步，也会达到相遇点M。显然在这个步骤当中 p1 和 p2 只有前 a 步走的路径不同，所以当 p1 和 p2 再次重合的时候，必然是在链表的环路入口点上。因为p1和p2点同时到达相遇点M，若都往后倒退b步则为环入口点，则第一次重合点必然是环路入口点。
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(31,ListNode(26,ListNode(18,ListNode(32)))) #在链表中构造环路 def cycle_list(l1): first = l1 temp = first for i in range(3): #向后移动三次，即将20作为入环节点 temp = temp.next while first.next: first = first.next first.next = temp return l1 l3 = cycle_list(l1) #l3.traverse() #返回入环点 def check_cycle_entrance(head): slow = fast = head found_cycle = False while fast!=None and fast.next!=None and not found_cycle: fast = fast.next.next slow = slow.next if slow is fast: #链表有环路 found_cycle=True if found_cycle: fast = head #快指针从头结点开始，一次走一步 while fast!=slow: fast = fast.next slow = slow.next return fast else: return None cycle_node = check_cycle_entrance(l3) print(cycle_node.data) cycle_node = check_cycle_entrance(l2) print(cycle_node)
（3）题目描述：输入一个单向链表，判断链表是否有环。如果链表存在环，计算环的长度？
解题思路： 由上题可知，按照 p2 每次两步，p1 每次一步的方式走，发现 p2 和 p1 重合，确定了单向链表有环路了。接下来，从相遇点继续走，那么当 p1 和 p2 再次相遇的时候，p1走过的长度即为环长度。
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(31,ListNode(26,ListNode(18,ListNode(32)))) #在链表中构造环路 def cycle_list(l1): first = l1 temp = first for i in range(3): #向后移动三次，即将20作为入环节点 temp = temp.next while first.next: first = first.next first.next = temp return l1 l3 = cycle_list(l1) #l3.traverse() #计算环路长度 def count_cycle_length(head): slow = fast = head found_cycle = False while fast!=None and fast.next!=None and not found_cycle: fast = fast.next.next slow = slow.next if slow is fast: #链表有环路 found_cycle=True if found_cycle: count = 1 fast = fast.next.next slow = slow.next while fast!=slow: #第二次相遇 fast = fast.next.next slow = slow.next count = count+1 return count else: return None cycle_length = count_cycle_length(l3) print(cycle_length)
（4）题目描述：输入一个单向链表，判断链表是否有环。如果链表存在环，计算链表长度？
解题思路：计算出第（2）题中a和第（3）题中的环路长，两者之和即为链表长度
判断链表的公共交点
题目描述：给出两个单向链表的头指针（如下图所示），求链表的交点
解题思路：求出两链表的长度，长链表先走，然后逐个比较两个链表的值，第一个相等的值即为交点。（若只要判断是否相交，只需判断尾节点是否相等）
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(31,ListNode(25,ListNode(10,ListNode(12)))) #判断链表交点 def linkedlist_node(l1,l2): head1 = l1 head2 = l2 length1=length2=0 while head1: length1 = length1+1 head1 = head1.next while head2: length2 = length2+1 head2 = head2.next if length1>length2: #长链表先走 for i in range(length1-length2): l1 = l1.next else: for i in range(length2-length1): l2 = l2.next while l1!=None and l2!=None: if l1.data = l2.data: #应该是l1==l2（或l1 is l2）,这里使用值代替了，方便看执行结果 return l1.data l1 = l1.next l2 = l2.next return None print(linkedlist_node(l1,l2))
2，有序列表（Ordered List）
有序列表和无序列表结构相同，只是列表中的数据按顺序排列（升序或降序），其常用操作也基本相同。
常用操作
Llist = OrderedList()
add(item)
remove(item)
search(item)
pop()
pop(pos)
index(item)
size()
isEmpty()
python 实现有序列表
pop(), index(item), size()和isEmpty()方法和UnorderedList相同，add(item), search(item)和remove(item)代码如下所示：
class OrderedList(object): def __init__(self): self.head = None def add(self,item): previous = None current = self.head while current and (item > current.getData()): previous = current current = current.getNext() temp = Node(item) if previous == None: temp.setNext(self.head) self.head=temp else: previous.setNext(temp) temp.setNext(current) def search(self,item): current = self.head found = False stop = False while current!=None and (not found) and (not stop): if current.getNext()==item: found =True else: if current.getData()<item: current = current.getNext() else: stop = True return found def remove(self,item): previous = None current = self.head while current and (item!=current.getData()): previous = current current = current.getNext() if current!=None: if previous == None: self.head = current.getNext() else: previous.setNext(current.getNext()) else: # self.head=None或者item不存在链表中 raise ValueError('%s item is not in the OrderedList'%item)
