知识迁移能力（1-8）

最新推荐文章于 2022-06-14 19:43:13 发布

qq_turn

最新推荐文章于 2022-06-14 19:43:13 发布

阅读量751

点赞数

分类专栏：剑指offer--知识点

本文链接：https://blog.csdn.net/qq_38441207/article/details/89282505

版权

剑指offer--知识点专栏收录该内容

22 篇文章 0 订阅

订阅专栏

题目描述1：数字在排序数组中出现的次数

统计一个数字在排序数组中出现的次数。

python测试：

// An highlighted block
class Solution:
    def GetNumberOfK(self,data,k):
        if len(data) == 0:
            return 0
        else:
            return data.count(k)

if __name__ == "__main__":

    a = Solution()
    b = [1,2,3,3,3]
    print(a.GetNumberOfK(b,3))

题目描述2：二叉树的深度

输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

python测试：

// An highlighted block
class Solution:
    def maxDepth(self,root):
        if not root:
            return 0
        else:
            l = 1+self.maxDepth(root.left)
            r = 1+self.maxDepth(root.right)
        return max(l,r)

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

if __name__ == '__main__':
    node = Node(1)
    node.left = Node(2)
    node.left.left = Node(3)
    node.left.right = Node(4)
    node.right = Node(5)
    node.right.right = Node(6)
    root = node
    a= Solution()

    print(a.maxDepth(root))

题目描述3：平衡二叉树

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

python测试：

// An highlighted block

class Solution:
    def IsBalanced_Solution(self,pRoot):
        if not pRoot: return True
        left = self.TreeDepth(pRoot.left)
        right = self.TreeDepth(pRoot.right)
        if abs(left - right) > 1:
            return False
        return self.IsBalanced_Solution(pRoot.left) and self.IsBalanced_Solution(pRoot.right)

    def TreeDepth(self,pRoot):
        if not pRoot: return 0
        left = self.TreeDepth(pRoot.left)
        right = self.TreeDepth(pRoot.right)

        return max(left, right) + 1

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

if __name__ == '__main__':
    node = Node(1)
    node.left = Node(2)
    node.left.left = Node(3)
    node.left.right = Node(4)
    node.right = Node(5)
    node.right.right = Node(6)
    root = node
    a= Solution()

    print(a.IsBalanced_Solution(root))

题目描述4：数组中只出现一次的数字

一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序找出这两个只出现一次的数字。

python测试：

// An highlighted block
class Solution:
    def FindNumsAppearOnce(self, array):
        tmp = []
        for a in array:
            # print("a: ", a)
            if a in tmp:
                tmp.remove(a)

            else:
                tmp.append(a)
        return tmp

if __name__ == "__main__":

    a = Solution()
    num = [3,3,5,5,2]

    data = a.FindNumsAppearOnce(num)
    print(data)

题目描述5：和为S的连续正数序列

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出描述:
输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

python测试：

// An highlighted block
class Solution:
    def FindContinuousSequence(self, tsum):
        res = []
        for i in range(1, tsum//2+1):
            sum = 0
            for j in range(i,tsum//2+2):
                sum += j
                if sum == tsum:
                    res.append(range(i,j+1))
        return res

if __name__ == "__main__":

    a = Solution()
    data = a.FindContinuousSequence(10)
    print(data)

https://blog.csdn.net/Sun_White_Boy/article/details/83419474

题目描述6：和为S的两个数字

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。
输出描述:
对应每个测试案例，输出两个数，小的先输出。

python测试：

// An highlighted block
class Solution:
    def FindNumbersWithSum(self,array,tsum):
        ls = []
        if not isinstance(array,list):
            return ls
        for i, v in enumerate(array):
            for v1 in array[i:]:
                if (v+v1) == tsum:
                    ls.append([v, v1])

        if ls:
            return ls[0]
        else:
            return ls

if __name__ == '__main__':
    a = Solution()
    arr = [1, 2, 3, 5, 9]
    sum = 7
    print(a.FindNumbersWithSum(arr, sum))

题目描述7：左旋转字符串

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

python测试：

// An highlighted block
class Solution:
    def reverse(self, s, l, r):
        while l < r:
            s[l],s[r] = s[r],s[l]
            l += 1
            r -= 1
    def LeftRotateString(self, s, n):
        if not s: return  s
        s = list(s)
        self.reverse(s, 0, n-1)
        self.reverse(s, n, len(s) - 1)
        self.reverse(s,0, len(s) - 1)
        return ''.join(s)

if __name__ == '__main__':
    a = Solution()
    b = 'abcsd'
    k = 2
    print(a.LeftRotateString(b, k))

题目描述8：翻转单词顺序列

牛客最近来了一个新员工Fish，每天早晨总是会拿着一本英文杂志，写些句子在本子上。同事Cat对Fish写的内容颇感兴趣，有一天他向Fish借来翻看，但却读不懂它的意思。例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

python测试：

// An highlighted block
class Solution:
    def ReverseSentence(self,s):
        if s is None or len(s) == 0:
            return s
        return " ".join(s.split(' ')[::-1])

if __name__ == "__main__":

    a = Solution()
    s = "student. a am I"
    print(a.ReverseSentence(s))

总结：

qq_turn

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
知识迁移能力（1-8）

题目描述1：数字在排序数组中出现的次数统计一个数字在排序数组中出现的次数。题目描述2：二叉树的深度输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。题目描述3：平衡二叉树输入一棵二叉树，判断该二叉树是否是平衡二叉树。题目描述4：数组中只出现一次的数字一个整型数组里除了两个数字之外，其他的数字都出现了偶数次。请写程序...
复制链接

扫一扫