案例三
链表的分化
题干：
对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。
给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。
* 测试样例：
* {1,4,0,,2,5},3
* {1,0,2,4,5}
解析：这是一个经典的荷兰过期问题，只是在这里要求在链表中完成；通过维护三个链表来完成，具体如下
小于链表、等于链表、大于链表
在维护的时候需要通过指针记录小于链表的尾部，需要通过指针记录等于链表的头部和尾部，需要通过指针记录大于链表的头部。
最后就可以通过以上的四个指针将三个链表连在一起。
class Node:
def __init__(self,data):
self.data = data
self.next = None
class LinkList:
def __init__(self):
self.head = None
def sort(self,arr,num):
if not arr:
return None
headmix = self.head #小于等于链表的头指针
mix = None #小于等于链表的尾指针
headmax = self.head #大于链表的头指针
maxx = None #大于链表的尾指针
#将数组中的元素创建节点链接到p上去
for i in range(len(arr)):
newNode = Node(arr[i])
if not self.head:
self.head = newNode
p = self.head
else:
p.next = newNode
p = newNode
p = self.head
while p:
if p.data <= num:
if not headmix:
headmix = p
mix = headmix
else:
mix.next = p
mix = mix.next
if p.data > num:
if not headmax:
headmax = p
maxx = headmax
else:
maxx.next = p
maxx = maxx.next
p = p.next
if headmix == None:
maxx.next = None
self.printlist(headmax)
# return headmax
elif headmax == None:
mix.next = None
self.printlist(headmix)
#return headmix
else:
mix.next = headmax
maxx.next = None
self.printlist(headmix)
# return headmix
def printlist(self,q):
while q:
print(q.data)
q = q.next
我这里写的时候是写了测试用例的，所以写了遍历链表的函数，如果是OJ环境下，可以不用写
案例四
打印两个链表的公共值
现有两个升序链表，且链表中均无重复元素。请设计一个高效的算法，打印两个链表的公共值部分。
给定两个链表的头指针head1和head2，请返回一个vector，元素为两个链表的公共部分。请保证返回数组的升序。两个链表的元素个数均小于等于500。保证一定有公共值
* 测试样例：
* {1,2,3,4,5,6,7},{2,4,6,8,10}
* 返回：[2.4.6]
#这是没有测试用例的
class Node:
def __init__(self,data):
self.data = data
self.next = None
class Solution:
def print_same(self,head1,head2):
while head1!=None and head2!=None:
if head1.data < head2.data:
head1 = head1.next
elif head1.data > head2.data:
head2 = head2.next
else:
print(head1.data)
head1 = head1.next
head2 = head2.next # 这是有测试用例的，里面有如何生成链表的头结点的方法
class Node:
def __init__(self,data):
self.data = data
self.next = None
class Linklist:
def __init__(self):
self.first = self.last = None
def insert_end(self,data):
newNode = Node(data)
if not self.last:
self.first = self.last = newNode
else:
self.last.next = newNode
self.last = newNode
class Solution:
def create_link(self,arr):
link = Linklist()
for item in arr:
link.insert_end(item)
return link
def print_same(self,arr1,arr2):
if len(arr1)==0 or len(arr2)==0:
return
link1 = self.create_link(arr1)
link2 = self.create_link(arr2)
p = link1.first
q = link2.first
while p!=None and q!=None:
if p.data < q.data:
p = p.next
elif p.data > q.data:
q = q.next
else:
print(p.data)
p = p.next
q = q.next
arr1 = [1,2,3,4,5,6,7]
arr2 = [2,4,6,8,10]
test = Solution()
test.print_same(arr1,arr2)案例五
链表的k逆序练习题
给定一个单链表的头结点head，实现一个调整单链表的函数，使每K个结点之间逆序，
若最后不够K个节点一组，则不调整最后几个节点。
测试用例：
1 2 3 4 5 6 7 8, k=3
调整为3 2 1 6 5 4 7 8
解题思路：
如果使用栈的话，时间复杂度为O(n)，空间复杂度为O(k)，而且要留意最后不满k个的结点，要正序输出
在这里我采用每遍历k个元素就逆序，时间复杂度为O(n)，空间复杂度为O(1)
个人感觉这个算法的整体思路特别清晰，但是真正实现起来的时候，很多细节需要注意
class Node:
def __init__(self,data):
self.data = data
self.next = None
class Linklist:
def __init__(self):
self.first = self.last = None
def create_linklist(self,arr):
if not arr:
return
for i in range(len(arr)):
newNode = Node(arr[i])
if not self.first:
self.first = self.last = newNode
else:
self.last.next = newNode
self.last = newNode
return self.first
def reverse(self,arr,k):
head = self.create_linklist(arr)
if not head:
return
if k<2:
return head
pcur = head #正在遍历的当前节点
pstart = None
ppre = None
pnext = None #待遍历的下一个节点
count = 1
while pcur:
pnext = pcur.next
if count == k:
if ppre == None:
pstart = head
head = pcur
else:
pstart = ppre.next
self.resign(ppre,pstart,pcur,pnext)
ppre = pstart
count = 0
count += 1
pcur = pnext
return head
def resign(self,left,start,end,right):
ppre = start
pcur = start.next
pnext = None
while pcur != right:
pnext = pcur.next
pcur.next = ppre
ppre = pcur
pcur = pnext
if left:
left.next = end
start.next = right