《剑指Offer》第二章（一）题3-8
为春招实习做准备，记录一下《剑指Offer》里面的面试题
第二章
面试题3：数组之中的重复数字。
这个题吧，虽然不难，但是不知道为什么就是看了很久，可能很久没有做算法题了。最后面一句话说的挺好的，给你出题之后，要问清楚题目，以及要求，时间效率优先还是空间效率优先，虽然我一般都会选择时间效率优先，因为内存现在都比较大了。
题目很简单，一个长度为n的数组，数字都在0~n-1，找出其中任意一个重复的数字，注意是任意一个。
书中讲到了三个算法：
1.时间复杂度是O(n)，空间复杂度也是O(n)
遍历数组，碰到一个数字，先在哈希表之中判断是否存在该数字，如果不存在，则将其放入到哈希表之中，如果存在，则找出一个重复的数字。
很明显，需要一个O(n)的哈希表，遍历数组O(n)复杂度
我感觉这种挺好的，好理解，也好实现，最多有O(n)的空间复杂度，但是面试肯定不可能问你这么简单的。
2.时间复杂度是O(n)，空间复杂度O(1)
首先明白最重要的一点，如果这个数组是没有重复数字的，那么当数组有序时，数字m就一定在m位置出现。同样的遍历数组，假设现在遍历到下标为i的数字m，判断i==m 是否成立，成立，则该数字就在他本身的位置，不成立，则判断数组之中下标为i,m两个数字是否相等，相等，则找到一个重复数字，不相等，则将下标为i,m的数字进行交换，将数字m放到他本来的位置，之后继续判断新的i下标处的数字，直到相等为止，i++，进行下一轮判断。
说实话一开始不理解他为什么要交换，最后想了一下，交换是为了让每一个数字都在它应该在的位置，这样当我们审查第i个数字m时，如果第m个数字就是m，已经被交换到了他应该在的位置，这时候比较就可以得出一个重复的数字。
下面是代码，可以看到，一定不能忘了对输入的有效性进行判断，这是一种良好的编程习惯吧，书上是c++,python 方便一点
class Solution:
def findDuplicate(self, nums) -> int:
# 找出一个重复数字
if nums == None: # 输入检测
return False
length = len(nums)
for num in nums: # 是否有超过范围的数字
if num > length-1 or num < 0:
return False
for i in range(length): # 遍历数组
while nums[i] != i: # 这个数字是否在它应该在的位置
if nums[i] == nums[nums[i]]: # 判断是否有重复
return nums[i]
# 没有重复则进行交换,nums[i] 和 nums[nums[i]]
temp = nums[i]
nums[i] = nums[temp]
nums[temp] = temp
return False
可以看到虽然有两个循环，但是每一个数字最多交换两次就可以到它自己的位置，所以总体的复杂度为O(n)。
3.不能修改原来数组
这种其实题目都和上面那一个不一样，要求不能修改原来的数组，并且长度是n+1,所有数字都在1~n之间。
先说一下一点。
由于数组长度是n+1，但是数字的范围都是在1~n之间，所以肯定是有重复数字的，和之前不同。
第一种方法：
创建一个n+1大小的数组，遍历原来的数组，将数字m复制到新数组的下标为m的位置，如果m位置已经有了数字，那么就说明这个数字是重复的，时间空间复杂度都是O(n)，还是比较简单的一种方法。
第二种方法：
时间复杂度O(nlogn)，空间复杂度O(1)
基本思想是利用二分法逐渐缩小重复数字的区间（注意这个区间是1~n，而不是原来的数组），最后找到重复数字。将数字1~n从中间分为两部分，1~m和m+1~n，然后判断数字1~m在数组之中出现的次数，如果大于m，那么说明1~m之间有重复数字，反之就是m+1~n，之后用相同的方法，逐渐缩小区间即可。但是这种方法不能找出全部的重复数字，因为当出现次数小于等于m时，无法判断是一个数字出现了两次，还是每个数字都出现了一次，如果是前一种情况，那么就丢失了重复数字。
代码如下：
class Solution:
def findDuplicate(self, nums) -> int:
# 找出一个重复数字
if nums == None: # 输入检测
return False
length = len(nums)
for num in nums: # 是否有超过范围的数字
if num > length-1:
return False
print("2222")
start = 1
end = length-1 # 对数字1-n，所以是length-1
while end >= start:
middle = int(((end-start)/2) + start) # 计算中点
count = self.countRange(nums, start, middle) # 统计数组之中start~middle数字在数组之中出现的次数
if end == start: # 判断是否查找结束
if count > 1: # 说明有重复数字
return start
else:
break
if count > (middle-start+1): # 比较出现次数和前值区间数字个数，大于则说明前置区间有重复数字
end = middle
else:
start = middle + 1
return False
def countRange(self, nums, start, end): # 统计某一个区间之内数字在数组之中出现的次数
if nums == None:
return False
count = 0
for i in nums:
if i <= end and i >= start:
count += 1
return count
面试题4：
这个题目很简单，判断一个数字是否在一个二维数组之中存在，这个二维数组从左向右递增，从上向下递增，书中的解法很巧妙，从一个具体的问题入手，将复杂的问题普遍化。
从右上角数字开始，比较该数字，如果该数字大于目标数字，则剔除最后一列，因为该数字之下的数字都大于该数字，肯定也大于目标数字了，同理该数字小于目标数字，则剔除第一行，当然如果相等了就结束。右上角和左下角都可以，但是左上角和右下角不行，因为无法通过判断来剔除一行或者一列。代码如下：
class Solution:
def find(self, nums, target, rows, columns) -> int:
if nums == None or rows < 0 or columns < 0 or target == None:
return False
row = 0
column = columns-1
while row < rows and columns >= 0:
if nums[row][column] == target:
return True
elif nums[row][column] > target: # 剔除最后一列
column -= 1
elif nums[row][column] < target: # 剔除最上面一行
row += 1
return False
没什么说得，右上角数字就是nums[row][column]
面试题5：
这个题目也很简单，给你一个字符串，将里面的空格进行替换，替换成 %20 ，一般特殊字符替换规则都是替换为%+ASCII的十六进制表示。
注意一个问题，替换之后的字符串会变长，所以进行替换时必须进行移动，不然会出现内存覆盖的现象，比如 空格 替换为 %20，一个字符变成了三个字符，如果直接插入，那就会将该空格之后的两个字符覆盖掉。
时间复杂度是O(n2)：n的平方
遍历字符串，碰到空格，就将空格之后的字符整体向后移动2个位置，然后将%20以当前位置为基准，插入即可。由于遇到空格就需要移动字符串，遍历又需要O(n)的复杂度，所以时间复杂度是O(N2)
时间复杂度为O(N)的方法：
很巧妙，反正我现在是想不到的。基本思路是先分配所需要的内存，从后向前遍历，这样子就不需要每次遇到空格都移动字符串了。具体来说，先遍历字符串，计算空格数量，然后计算出替换之后的字符串长度。接着声明两个指针，一个指向当前字符串的尾部p1，另一个指向替换之后字符串的尾部p2，使用p1从后向前进行遍历，对于碰到的字符，分两种情况进行讨论：
1.碰到了非空格字符，将p1所指的字符复制到p2位置处，并将p1，p2都向前移动一个位置
2.碰到了空格，此时，以p2为基准，在p2之前(包括p2)插入%20，并将p2向前移动三个位置，p1向前移动一个位置。
这样循环直到p1,p2互相重合，说明已经遍历完了字符串。
属实巧妙，相当于先计算出来需要多长的字符串，然后按照逻辑直接对字符串进行填充，而且空间复杂度也是O(1)，虽然直接申请一个字符串，然后无脑复制过去也可以，但是需要O(N)的空间复杂度，而且也显得笨笨的。
代码如下：
class Solution{ public void ReplaceBlank(StringBuilder stringBuilder, int length){ if(stringBuilder==null || length < 0){ return; } int originalLength = 0; //原字符串长度 int numberOfBlank = stringBuilder.count; //字符串之中空格的数量 int i = 0; while(stringBuilder.charAt(i) != '\0'){ originalLength++; //增加源字符串长度 if(stringBuilder.charAt(i) == ' '){ numberOfBlank++; } i++; } int newLength = originalLength + numberOfBlank * 2; //新字符串长度 if(newLength > length){ return; } int indexOfOriginal = originalLength; int indexOfNew = newLength; while(indexOfOriginal >= 0 && indexOfNew > indexOfOriginal) { if(stringBuilder.charAt(indexOfOriginal) == ' '){ //空格，进行%20填充 --时候就能够向前移动了 stringBuilder.replace(indexOfNew--, indexOfNew+1, "0"); stringBuilder.replace(indexOfNew--, indexOfNew+1, "2"); stringBuilder.replace(indexOfNew--, indexOfNew+1, "%"); }else{ //不是空格，正常填充字符 stringBuilder.replace(indexOfNew--, indexOfNew+1, stringBuilder.substring(indexOfOriginal, indexOfOriginal+1)); } --indexOfOriginal; //原字符串指针向前移动 } } }
java真操蛋，感觉的真的难用。
面试题6：从尾到头打印链表
这个题比较简单，纯粹就是复习回顾的，直接上代码；不过注意分析问题时候，这个题相当于是第一个遍历的节点，最后一个输出，即先进后出，典型的栈的特点，所以直接用栈来进行存储或者递归就可以了。
class ListNode:
def __init__(self, val=None):
self.val = val
self.next = None
def reverseOut(head: ListNode):
if head.next == None:
return
stack = []
while head.next:
stack.append(head.next.val)
head = head.next
while stack:
print(stack.pop())
# 测试
head = ListNode()
node = head
for i in range(10):
node.next = ListNode(i)
node = node.next
reverseOut(head)
递归方法很简单，不过层数会很深，2n次方级别的
def recursion(head: ListNode):
if head.next:
recursion(head.next)
print(head.next.val)
面试题7：重建二叉树
思路很简单，但是代码挺复杂的这个，暂时略过
面试题8，二叉树的下一个节点
题目：给定二叉树之中的一个节点，然后找出在中序遍历的结果之中，该节点的下一个遍历的节点。二叉树中每一个节点有一个额外的指针指向其父节点
问题分析：中序遍历很简单，“”左中右，所以可以想到，在当前节点遍历之后，如果它有右子树，那么就会遍历他的右子树最左边的那个节点，如果没有右子树的话，就说明当前节点和它的左子树(有的话)都已经遍历完了，该向上遍历了，根据中序遍历的特点，我们需要找到一个左子节点，以该左子节点为根节点的树都已经遍历完了，该遍历该左子节点的父节点了，所以它的父节点就是下一个需要遍历的节点。
所以，分为三种情况：
1.当前节点有右子树，那么下一个遍历的就是右子树的最左节点
当前节点没有右子树，可以分为两种情况
1.当前节点是左子节点，下一个遍历的就是该节点的父节点
2.当前节点是右节点并且没有右子树，有没有左子树不影响。向上回溯，找到一个左子节点，该节点的父节点即为所求。
但是其实1情况是二情况的一种特殊情况，即该节点本身就是左子节点，不需要再向上进行回溯，所以写代码时候当做一种情况写就可以了。
代码如下：
class BTree:
def __init__(self, val=None, left=None, right=None, parent=None):
self.val = val
self.left = left
self.right = right
self.parent = parent
def getNext(pNode: BTree):
if pNode == None:
return
pNext = None
# 有右子树的情况
if pNode.right != None:
temp = pNode.right
while temp.left: # 右子树的最左边的节点
temp = temp.left
pNext = temp
else:
current = pNode
parent = pNode.parent
# 向上回溯，找到一个节点为左子节点，循环条件：当前节点是右子节点且有父节点
while parent != None and current == parent.right:
current = parent
parent = parent.parent
pNext = parent
return pNext
测试起来比较麻烦，因为需要构建节点的父指针，得一个一个设置，简单写一个
a = BTree(val=0) d = BTree(val=3) g = BTree(val=6) b = BTree(val=1, left=d, parent=a) c = BTree(val=2, right=g, parent=a) d.parent = b g.parent = c a.left = b a.right = c print(getNext(d).val)
树结构很简单，不说了。
