剑指offer部分题目（二）

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


class Llst:
    def __init__(self):
        self.head = None
        self.end = None
    def print_l(self):
        cur = self.head
        while cur:
            print(cur.val)
            cur= cur.next
    def append(self, val):
        if not self.head:
            self.head = self.end = Node(val)
        else:
            cur = Node(val)
            self.end.next = cur
            self.end = cur

L = Llst()
for i in range(10):
    L.append(i)

#输入链表输出倒数第K个节点： 压栈弹出。 如果知道链表节点数，那么直接遍历到N-K即可
def K_node(k,l):
    l = []
    cur = L.head
    while cur:
        print(cur.val)
        l.append(cur)
        cur=cur.next
    return l[-k].val

#翻转链表，输出新表头
def rev(L):
    a, b = L.head, L.head.next
    while True:
        c=b.next
        if c == None:
            b.next = a
            L.head, L.end = L.end, L.head
            L.end.next = None
            return L.head.val
        b.next,a,b= a,b,c

# 输入两个递增的链表，输出合并有序链表
def solution():
    l = Llst()
    l2 = Llst()
    for i in range(0, 10, 2):  # 0,2,4,6,8
        l.append(i)
    for i in range(1, 10, 2):  # 1,3,5,7,9
        l2.append(i)
    cur1 = l.head
    cur2 = l2.head
    l3 = Llst()
    while True:
        l3.append(min(cur1.val, cur2.val))
        if cur1.val >= cur2.val:
            cur2 = cur2.next
            if cur2 == None:
                while cur1:
                    l3.append(cur1.val)
                    cur1 = cur1.next
                break
        else:
            cur1 = cur1.next
            if cur1 == None:
                while cur2:
                    l3.append(cur2.val)
                    cur2 = cur2.next
                break
    cur3 = l3.head
    while cur3:
        print(cur3.val)
        cur3 = cur3.next  # 合并成功

#实现包含min函数的栈，要求时间复杂度O1：
class Stack:
    def __init__(self):
        self.top = None
        self.number = 0
        self.mini = None
    def top(self):
        print(self.top.val)
        return self.top

    def min(self):
        print('the min is {}'.format(self.mini.val))
        return self.mini


    def push(self,val):
        if self.number == 0:
            print('init')
            self.top = Node(val)
            self.number =1
            self.mini = self.top
        else:
            n = Node(val)
            n.next, self.top = self.top, n
            self.number += 1
            self.mini = n if n.val <self.mini.val else self.mini

    def pop(self):
        if self.number ==1:
            print('弹完了')
            return self.top
        if self.top == self.mini:
            cur = self.top.next
            min = cur
            while cur:
                if cur.val < min.val:
                    min = cur
                cur = cur.next
        tar = self.top
        self.top = self.top.next
        self.number -= 1
        return tar

#输入两个整数序列，判断第二个栈是否有可能是第一个栈的出栈序列。所有数字不相等
#本质在于顺序有没有两个‘断层’,比如序号12345 压入，54321弹出，那么45321也行 ，但是45231就不行因为断层有两个。
def canbe(lst1,lst2):
    l_1 = []
    l_2 = []
    for i in enumerate(lst1):
        l_1.append(i)
    for i in lst2:
        for j in l_1:
            if j[1] == i:
                l_2.append((j[0],i))
    flag = -1
    asc = des = 0
    for i in range(len(l_2)-1):
        if l_2[i]> l_2[i+1]:
            des += 1
        else:
            asc +=1
    return False  if des >=2 and asc>=2 else True #如果上升和下降都出现了大于等于2 次，说明出现了至少2次‘断层’

#输入N 个数，返回最小的k个数：1.可以排序后返回前k个 2、使用堆排序
def ret_k():
    pass
#输入两个链表，找到公共节点：如果有公共节点，说明尾部重合，只要取俩链表长度短的那条，节点都存到字典里，然后长的那条开始遍历就行
#比较简单，先不写了


#链表是否有环： 通过快慢指针实现，指针相遇就有环，遇到None就无环


#在升序链表中存在重复节点，删除重复的，返回头指针： 比如 1,2，3,3,4,4,5 删除后 1,2,5
def del_dup(L):
    a = L.head
    b = a.next
    cur = L.head
    flag = 0
    while True:
        if a.val == b.val:
            print('将要删除')
            a.next = b.next
            b =a.next
            flag =1
            print(a.val,b.val)
            continue
        if flag ==1 and a == L.head:#如果头部重复要特殊处理
            a,b = b,b.next
            print('头部删除后，新的a和b 是',a.val)
            L.head = a
            flag = 0
            if b==None:
                return L.head
            continue
        if b== None:
            return L.head.val
        else:
            a,b = b,b.next
            if b==None:
                return L.head