牛客网剑指offer【Python实现】——part2

不用加减乘除做加法

写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

两个数异或：相当于每一位相加，而不考虑进位；

两个数相与，并左移一位：相当于求得进位；

将上述两步的结果相加


python没有无符号左移操作，所以需要越界检查，加法是异或，进位是与<<1

https://blog.csdn.net/lrs1353281004/article/details/87192205

def Add(self, num1, num2):
        # write code here
        while(num2):
           num1,num2 = (num1^num2) & 0xFFFFFFFF,((num1&num2)<<1) & 0xFFFFFFFF
        return num1 if num1<=0x7FFFFFFF else ~(num1^0xFFFFFFFF)

        # 用 ctypes 来定义 c 语言的数据类型
        import ctypes
        def c_int(v): return ctypes.c_int(v).value

        while num2 != 0:
            num1, num2 = c_int(num1 ^ num2), c_int((num1 & num2) << 1)
        return num1

二进制中1的个数

输入一个整数，输出该数二进制表示中1的个数。其中负数用补码表示。

n与n-1进行按位与，最靠右的1置零，其他的高位的1没有发生变化，每运行一次，就可以知道有一个1


负数在计算机是以补码存在的，最高位为1，而负数往右移，符号位不变，符号位1往右移，最终可能会出现全1的情况，导致死循环，与0xFFFFFFFF相与，可以消除负数的影响

def NumberOf1(self, n):
        # write code here
        n = 0xFFFFFFFF & n
        count = 0
        for c in str(bin(n)):
            if c == "1":
                count += 1
        return count

		# write code here
        count = 0
        for i in range(32):
            mask = 1 << i
            if n & mask != 0:
                count += 1
        return count

		#循环次数最少
		count = 0
        if n < 0:
            n = n & 0xffffffff
        while n:
            count += 1
            n = (n - 1) & n
        return count

重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

# -*- coding:utf-8 -*-
class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        if not pre or not tin:
            return None
        if len(pre) != len(tin):
            return None
        # 取出pre的第一个值：根节点
        root = pre[0]
        rootNode = TreeNode(root)
        # 找到在中序遍历中的根节点所在的索引位置
        pos = tin.index(root)
        # 中序遍历的列表的左右节点分开切片成两个列表
        tinLeft = tin[0:pos]
        tinRight = tin[pos + 1:]
        # 前序遍历的列表的左右节点分开切片成两个列表
        preLeft = pre[1:pos + 1]
        preRight = pre[pos + 1:]

        leftNode = self.reConstructBinaryTree(preLeft, tinLeft)
        rightNode = self.reConstructBinaryTree(preRight, tinRight)

        rootNode.left = leftNode
        rootNode.right = rightNode
        return rootNode

字符串的排列

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

# -*- coding:utf-8 -*-
class Solution:
    def Permutation(self, ss):
        if len(ss) <= 1:
            return ss
        res = set()
        # 遍历字符串，固定第一个元素，第一个元素可以取a,b,c...，然后递归求解
        for i in range(len(ss)):
            for j in self.Permutation(ss[:i] + ss[i+1:]): # 依次固定了元素，其他的全排列（递归求解）
                res.add(ss[i] + j) # 集合添加元素的方法add(),集合添加去重（若存在重复字符，排列后会存在相同，如baa,baa）
        return sorted(res)         # sorted()能对可迭代对象进行排序,结果返回一个新的list

求1+2+3+...+n

求1+2+3+...+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

递归+短路原理：逻辑与两侧为真默认输出后边的真值

# -*- coding:utf-8 -*-
class Solution:
    def Sum_Solution(self, n):
        # write code here
        return n and (n + self.Sum_Solution(n - 1))

---

未完待续...