给定数组 求和等于固定值 算法_算法练习题

2.13 小范围排序练习题

已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过k，并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。

给定一个int数组A，同时给定A的大小n和题意中的k，请返回排序后的数组。

思路：maxheap

class ScaleSort:
    def sortElement(self, A, n, k):

2.14 重复值判断练习题

请设计一个高效算法，判断数组中是否有重复值。必须保证额外空间复杂度为O(1)。

给定一个int数组A及它的大小n，请返回它是否有重复值。

思路：maxheap

class Checker:
    def checkDuplicate(self, A, n):

2.15 有序数组合并练习题

有两个从小到大排序以后的数组A和B，其中A的末端有足够的缓冲空容纳B。请编写一个方法，将B合并入A并排序。

给定两个有序int数组A和B，A中的缓冲空用0填充，同时给定A和B的真实大小int n和int m，请返回合并后的数组

思路 ：设置三个指针，分别指向 k = m + n - 1 i = n - 1 j = m -1

class Merge:
    def mergeAB(self, A, B, n, m):

2.17 三色排序练习题

有一个只由0，1，2三种元素构成的整数数组，请使用交换、原地排序而不是使用计数进行排序。

给定一个只含0，1，2的整数数组A及它的大小，请返回排序后的数组。保证数组大小小于等于500。

思路：三个指针，i，j，k分别负责移动指针，0的指针，2的指针。

class ThreeColor:
    def sortThreeColor(self, A, n):

2.18 有序矩阵查找

现在有一个行和列都排好序的矩阵，请设计一个高效算法，快速查找矩阵中是否含有值x。

给定一个int矩阵mat，同时给定矩阵大小nxm及待查找的数x，请返回一个bool值，代表矩阵中是否存在x。所有矩阵中数字及x均为int范围内整数。保证n和m均小于等于1000。

思路：从右上角开始查找

class Finder:
    def findX(self, mat, n, m, x):

2.19 最短子数组

对于一个数组，请设计一个高效算法计算需要排序的最短子数组的长度。

给定一个int数组A和数组的大小n，请返回一个二元组，代表所求序列的长度。(原序列位置从0开始标号,若原序列有序，返回0)。保证A中元素均为正整数。

思路：向右，通过和max比较，找到错误的最右的地方，向右，通过和min比较，找到错误最左的位置

class Subsequence:
    def shortestSubsequence(self, A, n):

2.20 相邻两数最大差值

有一个整形数组A，请设计一个复杂度为O(n)的算法，算出排序后相邻两数的最大差值。

给定一个int数组A和A的大小n，请返回最大的差值。保证数组元素多于1个。

思路：桶排序的思想，n个桶，只考虑桶之间的大小。

class Gap:
    def maxGap(self, A, n):

3.2 拓扑结构相同子树

对于两棵彼此独立的二叉树A和B，请编写一个高效算法，检查A中是否存在一棵子树与B树的拓扑结构完全相同。

给定两棵二叉树的头结点A和B，请返回一个bool值，代表A中是否存在一棵同构于B的子树。

在做二叉树之前先整理一下二叉树的构建。

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None

def createTreeByListWithRecursion(preOrderList):
    """
    根据前序列表重建二叉树
    :param preOrder: 输入前序列表
    :return: 二叉树
    """
    preOrder = preOrderList
    if preOrder is None or len(preOrder) <= 0:
        return None

    currentItem = preOrder.pop(0) # 模拟C语言指针移动
    if currentItem is '#':
        root = None
    else:
        root = TreeNode(currentItem)
        root.left = createTreeByListWithRecursion(preOrder)
        root.right = createTreeByListWithRecursion(preOrder)
    return root

思路：通过某种遍历方法遍历两颗树，通过mpk判定字符串A是否包含字符串B

class IdenticalTree:
    def node(self,A):
        result = ''
        q = []
        if A:
            q.append(A)
        while q:
            x = q.pop(-1)
            if x:
                result+=str(x.val)
                q.append(x.right)
                q.append(x.left)
                
            else:
                result += '#'
        return result
    def chkIdentical(self, A, B):
        # write code here
        result1 = self.node(A)
        result2 = self.node(B)
        
        if result2 in result1:
            return True
        else:
            return False

3.3 词语变形

对于两个字符串A和B，如果A和B中出现的字符种类相同且每种字符出现的次数相同，则A和B互为变形词，请设计一个高效算法，检查两给定串是否互为变形词。

给定两个字符串A和B及他们的长度，请返回一个bool值，代表他们是否互为变形词。

思路：就是利用字典，记录一遍A，检测一遍B

class Transform:
    def chkTransform(self, A, lena, B, lenb):
        # write code here
        if not lena == lenb:
            return False
        k = {}
        for i in A:
            if i not in k:
                k[i] = 0
            k[i] += 1
        for i in B:
            if i in k:
                if k[i]==1:
                    k.pop(i)
            else:
                return False
        return True

3.5 两串旋转

如果对于一个字符串A，将A的前面任意一部分挪到后边去形成的字符串称为A的旋转词。比如A="12345",A的旋转词有"12345","23451","34512","45123"和"51234"。对于两个字符串A和B，请判断A和B是否互为旋转词。

思路：设置AA（把字符串复制到尾部）那么如果是旋转，那么B肯定在AA里能找到。

class Rotation:
    def chkRotation(self, A, lena, B, lenb):
        def fun(A,B):
            A=A+A
            if B in A:
                return True
            else:
                return False
        # write code here
        if lena!=lenb:
            return False
        return fun(A,B) and fun(B,A)

3.10 空格替换

请编写一个方法，将字符串中的空格全部替换为“%20”。假定该字符串有足够的空间存放新增的字符，并且知道字符串的真实长度(小于等于1000)，同时保证字符串由大小写的英文字母组成。

给定一个stringiniString为原始的串，以及串的长度 intlen, 返回替换后的string。

思路：遍历两遍，第一遍，count有多少的空格。第二遍从字符串最后边向前遍历。设置两个指针，一个为遍历当前位置i，一个为最终需要放置位置j。

class Replacement:
    def replaceSpace(self, iniString, length):
        # write code here
        iniString = list(iniString)
        num = 0
        for i in iniString:
            if i == ' ':
                num += 1
        length2 = length + num*2
        app = [None for i in range(num*2)]
        iniString =iniString  +app
        k = length2-1
        for i in range(length-1,-1,-1):
            if iniString[i] !=' ':
                iniString[k] =  iniString[i]
                k -= 1
            else:
                iniString[k] = '0'
                iniString[k-1] = '2'
                iniString[k-2] = '%'
                k -= 3
        return ''.join(iniString)

3.12 最长无重复字符子串

对于一个字符串,请设计一个高效算法，找到字符串的最长无重复字符的子串长度。

给定一个字符串A及它的长度n，请返回它的最长无重复字符子串长度。保证A中字符全部为小写英文字符，且长度小于等于500。

思路：用pre标记上一次重复出现的最右边的位置。

class DistinctSubstring:
    def longestSubstring(self, A, n):
        # write code here
        pre = -1
        max_len = 0
        mmap={}
        for i in range(n):
            if A[i] not in mmap:
                mmap[A[i]] = i
                if i-pre > max_len:
                    max_len = i-pre
            else:
                pre = x = max(pre,mmap[A[i]])
                if i-x > max_len:
                    max_len = i-x
                mmap[A[i]] = i
        return max_len

4.1 可查询最值的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

思路有两种：stackmin只压入当前最小数，弹出的时候，只有弹出的数和stackmin同，才弹出。

class Solution:
    def __init__(self):
        self.stack = []
        self.stackmin = []
    def push(self, node):
        # write code here
        self.stack.append(node)
        if len(self.stackmin)>0:
            x = self.stackmin[-1]
            if x > node:
                self.stackmin.append(node)
        else:
            self.stackmin.append(node)
    def pop(self):
        # write code here
        if len(self.stack)>0:
            x = self.stack.pop(-1)
            x_min = self.stackmin[-1]
            if x == x_min:
                self.stackmin.pop(-1)
    def top(self):
        # write code here
        return self.stack[-1]
    def min(self):
        return self.stackmin[-1]

4.3 双栈队列练

编写一个类,只能用两个栈结构实现队列,支持队列的基本操作(push，pop)。

给定一个操作序列ope及它的长度n，其中元素为正数代表push操作，为0代表pop操作，保证操作序列合法且一定含pop操作，请返回pop的结果序列。

思路：建立两个栈，pushstack，popstack，出栈的时候从popstack出来（如果没有，把popstack的元素全部压过来）

class TwoStack:
    def __init__(self):
        self.stackPush = []
        self.stackPop = []
    def twoStack(self, ope, n):
        # write code here
        res = []
        for x in ope:
            if x > 0:
                self.stackPush.append(x)
            else:
                if len(self.stackPop):
                    res.append(self.stackPop.pop())
                else:
                    while len(self.stackPush):
                        self.stackPop.append(self.stackPush.pop())
                    res.append(self.stackPop.pop())
        return res

4.5 栈的反转

实现一个栈的逆序，但是只能用递归函数和这个栈本身的pop操作来实现，而不能自己申请另外的数据结构。

给定一个整数数组A即为给定的栈，同时给定它的大小n，请返回逆序后的栈。

思路：递归栈中，抽出最底下的元素，再入栈。

class StackReverse:
    def reverseStack(self, A, n):
        # write code here
        if len(A)<=0:
            return A
        A,x = self.get(A)#找出最地下的数等价于 A.pop(0)
        if len(A) <= 0:
            A.append(x)
            return A
        else:
            A = self.reverseStack(A,len(A))
            A.append(x)
            return A
    def get(self,A):
        if len(A)>0:
            x = A.pop(-1)
            if len(A)<=0:
                return A,x
            else:
                A,k = self.get(A)
                A.append(x)
        return A,k

4.6 双栈排序

请编写一个程序，按升序对栈进行排序（即最大元素位于栈顶），要求最多只能使用一个额外的栈存放临时数据，但不得将元素复制到别的数据结构中。

思路：双stack，第二个stack是有序的排入进去，第一个做缓冲区

class TwoStacks:
    def twoStacksSort(self, numbers):
        # write code here
        help = []
        while len(numbers)>0:
            x = numbers.pop(-1)
            while len(help)>0:
                k = help[-1]
                if x <= k:
                    break
                help.pop(-1)
                numbers.append(k)
            help.append(x)
        return help

4.8 滑动窗口

有一个整型数组 arr 和一个大小为 w 的窗口从数组的最左边滑到最右边,窗口每次向右边滑一个位置。 返回一个长度为n-w+1的数组res，res[i]表示每一种窗口状态下的最大值。 以数组为[4,3,5,4,3,3,6,7]，w=3为例。因为第一个窗口[4,3,5]的最大值为5，第二个窗口[3,5,4]的最大值为5，第三个窗口[5,4,3]的最大值为5。第四个窗口[4,3,3]的最大值为4。第五个窗口[3,3,6]的最大值为6。第六个窗口[3,6,7]的最大值为7。所以最终返回[5,5,5,4,6,7]。

给定整形数组arr及它的大小n，同时给定w，请返回res数组。保证w小于等于n，同时保证数组大小小于等于500。

思路：维护一个Qmax的,Qmax的值要么最新，要么arr【j】的值大。qmax【0】就是所谓的要找的下标。每次移动窗口，允许后面的比qmax【0】指的值小，不允许后面的比【0】大，如果大了，就剔除小的进入大的。

class SlideWindow:
    def slide(self, arr, n, w):
        # write code here
        qmax= []
        res = []
        for i,x in enumerate(arr):
            while len(qmax)>0:
                j=qmax[-1]
                if arr[j] > arr[i]:
                    break
                else:
                    qmax.pop(-1)
            qmax.append(i)
            if i >= w-1:
                while i-qmax[0] >= w:
                    qmax.pop(0)
                res.append(arr[qmax[0]])
        return res

5.2 环形链表插值

有一个整数val，如何在节点值有序的环形链表中插入一个节点值为val的节点，并且保证这个环形单链表依然有序。

给定链表的信息，及元素的值A及对应的nxt指向的元素编号同时给定val，请构造出这个环形链表，并插入该值。

思路： 先把val大于整个链表或者小于整个链表的解决了，然后才插入链表中。

class InsertValue:
    def insert(self, A, nxt, val):
        # write code herew
        nodeT=ListNode(val)
        if len(A)<=0:
            return nodeT
        
        head = ListNode(A[0])
        p = head
        for i in range(1,len(A)):
            p.next = ListNode(A[i])
            p = p.next
        #p.next = head
        if head.val>val:
            #r.next=nodeT
            nodeT.next=head
            head=nodeT
            return head
        if p.val<val:
            p.next=nodeT
            nodeT.next=None
            return head
             
        pre,now=head,head.next
        while True:
            if pre.val<=val and now.val>=val:
                break
            else:
                pre=pre.next
                now=now.next
        pre.next=nodeT
        nodeT.next=now
        return head

5.4 链表的分化

对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。

给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。

思路：跟快排的其中步骤一样，生成两个链表，一个是小于等于a，一个大于a，然后连接起来

class Divide:
    def listDivide(self, head, val):
        # write code here
        # write code here
        if not head or head.next is None:
            return head
        tlist = [ListNode(None) for i in range(3)]
        node = head
        x,y,z = tlist[0],tlist[1],tlist[2]
        p = head
        while p:

            if p.val <= val:
                x.next = ListNode(p.val)
                x = x.next
            else:
                z.next = ListNode(p.val)
                z = z.next
            p = p.next
        head = ListNode(None)
        p = head
        if tlist[0].next:
            p.next = tlist[0].next
            p = x
        if tlist[1].next:
            p.next = tlist[1].next
            p = y
        if tlist[2].next:
            p.next = tlist[2].next
            p = z
            p.next = None
        return head.next

5.5 链表的k逆序

有一个单链表，请设计一个算法，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null，K=3这个例子。调整后为，3->2->1->6->5->4->7->8->null。因为K==3，所以每三个节点之间逆序，但其中的7，8不调整，因为只有两个节点不够一组。

思路：类似链表的倒序的方法，只是多加了K个倒序的条件。倒序思路是cur.next 插入到pre和cur之间。

class KInverse:
    def inverse(self, head, k):
        # write code here
        if not head:
            return None
        prehead = ListNode(0)
        prehead.next = head
        pre = prehead
        cur = head
        while True:
            flag = 0
            temp= cur
            for i in range(k):
                if not temp:
                    flag =1
                    break
                temp = temp.next
            if flag:
                break
            for i in range(k-1):
                temp = cur.next
                cur.next = temp.next 
                temp.next = pre.next
                pre.next = temp
            pre = cur
            cur = cur.next
        return prehead.next

5.11 复杂链表的复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点）。

思路：复制的思路在于，由于有两个指针，其中一个还是随机指针，不能直接按顺序复制就完了。这里用到的技巧是1->1'->2->2'->3->3'这样，的方式，第一次遍历先复制好上面的结构，然后第二遍便利，把random指针给安排清楚。第三次遍历，把它分成两串

# class RandomListNode:
#     def __init__(self, x):
#         self.label = x
#         self.next = None
#         self.random = None
class Solution:
    # 返回 RandomListNode
    def Clone(self, pHead):
        # write code here
        if not pHead:
            return None
        p  = pHead
        while p:
            q = RandomListNode(p.label)
            q.next = p.next
            p.next = q
            p = q.next
        p = pHead
        while p:
            if p.random:
                p.next.random = p.random.next
            p = p.next.next
        qHead = RandomListNode(0)
        t = qHead
        p = pHead
        while p :
            t.next = p.next
            t = t.next
            p.next = t.next
            p = p.next
            if p:
                t.next = p.next
        return qHead.next

5.12 判断环，环点

如何判断一个单链表是否有环？有环的话返回进入环的第一个节点的值，无环的话返回-1。如果链表的长度为N，请做到时间复杂度O(N)，额外空间复杂度O(1)。

思路：通过快慢指针，进行寻找环，然后通过下面证明方式找到入环点。

2(L+x) = L+x+n*H (n >= 1) // n 为快指针在闭环上的圈数

=> 2L+2x = L+x+n*H (n >= 1)

=> L = n*H-x (n >= 1)

=> L = n*(H-x)+(n-1)x (n >= 1)

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class ChkLoop:
    def chkLoop(self, head, adjust):
        # write code here
        fast = head
        slow = head
        while fast and fast.next:
            fast = fast.next.next
            slow = slow.next
            if fast == slow:
                fast = head
                while fast != slow:
                    fast  = fast.next
                    slow = slow.next
                return fast.val
        return -1

5.15 单链表相交

给定两个单链表的头节点head1和head2，如何判断两个链表是否相交？相交的话返回true，不想交的话返回false。

思路：先判断有没有环，有环。两个有都与环，判断相交点，一个有环一个没有，false。两个都没有，就按照无环链表来解题。

# -*- coding:utf-8 -*-
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class ChkIntersection:
    def chkInter(self, head1, head2, adjust0, adjust1):
        a, b = findCircle(head1), findCircle(head2)  # 找出环内点
        if a and b:            
            p = a.next
            while True:
                if p == b:
                    return True
                if p == a:
                    break
                p = p.next
            return False
        elif a or b:
            return False
        else:
            lenA = self.cout_len(head1)
            lenB = self.cout_len(head2)
            if lenA >= lenB:
                long = headA
                short = headB
            else:
                long = headB
                short = headA
            for i in range(abs(lenA-lenB)):
                long=long.next
            while long and short:
                if long == short:
                    return True
                long = long.next
                short = short.next
            return False
    def cout_len(self,head):
        count = 0
        p = head
        while p:
            count += 1
            p = p.next
        return count
 
def findCircle(head):
    p = q = head
    while q and q.next:
        p, q = p.next, q.next.next
        if p == q:
            return p
    return None