《剑指Offer》题三十一~题四十
三十一、栈的压入、弹出序列
题目：输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的数字均不相等。例如，序列{1, 2, 3, 4 ,5}是某栈的压栈序列，序列{4, 5, 3, 2, 1}是该压栈序列对应的一个弹出序列，但{4, 3, 5, 1, 2}就不可能是该压栈序列的弹出序列。
分析：本题中的压栈序列并非是一次全部压入堆栈！如果没有思路，可以举一两个例子，一步步分析压栈、弹出的过程，从中找出规律。
三十二、从上到下打印二叉树
题目一：不分行从上到下打印二叉树。从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。
分析：二叉树的层次遍历。
队列解法：
void print_top_to_bottom(BinaryTreeNode *pRoot)
{
if(pRoot == nullptr) return;
queue<BinaryTreeNode*> que; // 用于层次遍历
que.push(pRoot);
while(!que.empty()) {
BinaryTreeNode *pNode = que.front();
que.pop();
printf("%d\t", pNode->value);
if(pNode->lChild != nullptr) que.push(pNode->lChild);
if(pNode->rChild != nullptr) que.push(pNode->rChild);
}
}
小结：层次遍历这一过程可概括为，首先把起始节点（如根节点）放入队列，接下来每次从队列的头部取出一个节点，遍历这个节点之后把它能到达的节点（如子节点）都依次放入队列，重复这个遍历过程，直到队列中的节点全部被遍历为止。
题目二：分行从上到下打印二叉树。从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
分析：为了把二叉树的每一行单独打印到一行里，我们需要两个变量，toBePrinted变量表示在当前层中还没有打印的节点数，nextLevel变量表示下一层的节点数。
解法：
void print_by_row(BinaryTreeNode *pRoot)
{
if(pRoot == nullptr) return;
queue<BinaryTreeNode*> que;
que.push(pRoot);
int toBePrinted = 1;
int nextLevel = 0;
while(!que.empty()) {
BinaryTreeNode *pNode = que.front();
que.pop();
toBePrinted--;
printf("%d\t", pNode->value);
if(toBePrinted == 0) {
printf("\n");
toBePrinted = nextLevel;
nextLevel = 0;
}
if(pNode->lChild != nullptr) {
que.push(pNode->lChild);
nextLevel++;
}
if(pNode->rChild != nullptr){
que.push(pNode->rChild);
nextLevel++;
}
}
}
题目三：之字形打印二叉树。请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
分析：如果找不到解决办法，可以试着用具体的例子一步步分析。可知，按之字形打印需要两个栈，如果当前打印的是奇数层（第一层、第三层等），则先保存左子节点再保存右子节点到第一个栈里；如果当前打印的是偶数层，则先保存右子节点再保存左子节点到第二个栈里。之所以需要两个栈，是因为栈是后入先出的容器，故用一个栈不能将同一层的节点依次打印出来。
解法：
void print(BinaryTreeNode *pRoot)
{
if(pRoot == nullptr) return;
stack<BinaryTreeNode*> levels[2];
int current = 0;
int next = 1;
levels[0].push(pRoot);
while(!levels[0].empty() || !levels[1].empty()) {
BinaryTreeNode *pNode = levels[current].top();
levels[current].pop();
printf("%d\t", pNode->value);
if(current == 0) {
if(pNode->lChild != nullptr)
levels[next].push(pNode->lChild);
if(pNode->rChild != nullptr)
levels[next].push(pNode->rChild);
}
else {
if(pNode->rChild != nullptr)
levels[next].push(pNode->rChild);
if(pNode->lChild != nullptr)
levels[next].push(pNode->lChild);
}
if(levels[current].empty()) {
printf("\n");
current = 1 - current;
next = 1 - next;
}
}
}
小结：本题表面看上去像层次遍历，但不能用队列来实现，故应该根据具体情况选用合适的数据结构和算法。
三十三、二叉搜索树的后序遍历序列
题目：输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。假设输入的数组的任意两个数字互不相同。
分析：要完成这道题，需要先掌握后序遍历这一定义。比如，对于后序遍历序列{5, 7, 6, 9, 11, 10, 8}，最后一个数字{8}是树的根节点的值，而前面6个数字可以分为两部分，第一部分{5, 7, 6}是左子树节点的值，它们都比根节点的值小，第二部分{9, 11, 10}是右子树节点的值，它们都比根节点的值大。接下来，我们可以用同样的方法来处理这两个子序列{5, 7, 6}和{9, 11, 10}。这其实就是一个递归的过程。
解法：
bool seq_of_BST(int *seq, int length)
{
if(seq == nullptr || length <= 0) return false;
int root = seq[length - 1];
// 在BST中，左子树节点的值小于根节点的值
int i = 0;
for(; i < length - 1; ++i) {
if(seq[i] > root)
break;
}
// 在BST中，右子树节点的值大于根节点的值
for(int j = i; j < length - 1; ++j) {
if(seq[j] < root)
return false;
}
// 递归，判断左子树是不是二叉搜索树
bool left = true;
if(i > 0) left = seq_of_BST(seq, i);
// 递归，判断右子树是不是二叉搜索树
bool right = true;
if(i < length - 1) right = seq_of_BST(seq + i, length - i - 1);
return (left && right);
}
三十四、二叉树中和为某一值的路径
题目：输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。
提示：一般的数据结构教材中都没有介绍树的路径，因此对大多数应聘者而言，这是一个新概念，此时我们可以试着从一两个具体的例子入手，找到规律。
分析：路径是从根节点出发到叶节点，即路径总是以根节点为起始点，因此我们首先需要遍历根节点，故必须选择前序遍历这一方式。
三十五、复杂链表的复制
题目：请实现函数ComplexListNode* Clone(ComplexListNode *pHead)，复制一个复杂链表。在复杂链表中，每个节点除了有一个m_pNext指针指向下一个节点，还有一个m_pSibling指针指向链表中的任意节点或者nullptr。
分析：本题中的复杂链表是一种不太常见的数据结构，并且复制这种链表的过程也较为复杂。我们可以把复杂链表的复制过程分解成3个步骤，这样能帮我们理清思路。
三步解法：
ComplexListNode* Clone(ComplexListNode* pHead)
{
CloneNodes(pHead);
ConnectSiblingNodes(pHead);
return ReconnectNodes(pHead);
}
void CloneNodes(ComplexListNode* pHead)
{
ComplexListNode* pNode = pHead;
while(pNode != nullptr)
{
ComplexListNode* pCloned = new ComplexListNode();
pCloned->m_nValue = pNode->m_nValue;
pCloned->m_pNext = pNode->m_pNext;
pCloned->m_pSibling = nullptr;
pNode->m_pNext = pCloned;
pNode = pCloned->m_pNext;
}
}
void ConnectSiblingNodes(ComplexListNode* pHead)
{
ComplexListNode* pNode = pHead;
while(pNode != nullptr)
{
ComplexListNode* pCloned = pNode->m_pNext;
if(pNode->m_pSibling != nullptr)
{
pCloned->m_pSibling = pNode->m_pSibling->m_pNext;
}
pNode = pCloned->m_pNext;
}
}
ComplexListNode* ReconnectNodes(ComplexListNode* pHead)
{
ComplexListNode* pNode = pHead;
ComplexListNode* pClonedHead = nullptr;
ComplexListNode* pClonedNode = nullptr;
if(pNode != nullptr)
{
pClonedHead = pClonedNode = pNode->m_pNext;
pNode->m_pNext = pClonedNode->m_pNext;
pNode = pNode->m_pNext;
}
while(pNode != nullptr)
{
pClonedNode->m_pNext = pNode->m_pNext;
pClonedNode = pClonedNode->m_pNext;
pNode->m_pNext = pClonedNode->m_pNext;
pNode = pNode->m_pNext;
}
return pClonedHead;
}
三十六、二叉搜索树与双向链表
题目：输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。
三十七、序列化二叉树
题目：请实现两个函数，分别用来序列化和反序列化二叉树。
三十八、字符串的排列
题目：输入一个字符串，打印出该字符串中字符的所有排列。例如，输入字符串"abc"，则打印出由字符a、b、c所能排列出来的所有字符串abc、acb、bac、bca、cab和cba。
三十九、数组中出现次数超过一半的数字
题目：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
分析：最直观的解决方法是将该数组排序，然后找出该数字，但这种方法的时间复杂度为O(nlogn)。我们要思考时间复杂度为O(n)的方法。
四十、最小的K个数
题目：输入n个整数，找出其中最小的K个数。
提示：和上题一样，我们可以将这n个整数排序，排序之后位于最前面的K个数就是最小的K个数，但这种思路的时间复杂度为O(nlogn)。我们需要更快的方法。
分析：我们可以先创建一个大小为K的数据容器来存储最小的K个数字，接下来每次从输入的n个整数中读入一个数。如果容器中已有的数字少于K个，则直接把这次读入的整数放入容器之中；如果容器中已有K个数字了，我们要做3件事情（①在K个整数中找到最大数；②有可能在这个容器中删除最大数；③有可能要插入一个新的数字）。如果用一棵二叉树来实现这个数据容器，比如最大堆，它每次可以在O(1)时间内得到已有的K个数字中的最大值，在O(logk)时间内完成删除及插入操作。但我们自己从头实现一个最大堆需要一定的代码，在面试中很难完成，故我们还可以采用红黑树来实现这个容器，而在红黑树中的查找、删除和插入操作都只需要O(logk)时间。因为set和multiset都是基于红黑树实现的，故本题可使用multiset来作为容器。
解法：
typedef multiset<int, greater<int>> intSet;
typedef multiset<int, greater<int>>::iterator setIterator;
void get_least_numbers(const vector<int> &data, intSet &leastNumbers, int k)
{
if(k < 1 || data.size() < k) return;
leastNumbers.clear();
vector<int>::const_iterator iter = data.begin();
for(; iter != data.end(); ++iter) {
if(leastNumbers.size() < k)
leastNumbers.insert(*iter);
// 容器已满时
else {
setIterator iterGreatest = leastNumbers.begin();
// 在该multiset<int, greater<int>>类型中，第一个元素最大
if(*iter < *(leastNumbers.begin())) {
// 删除最大数，插入一个新数
leastNumbers.erase(iterGreatest);
leastNumbers.insert(*iter);
}
}
}
}
小结：在上段代码中，每次输入一个新元素时，需要O(logk)时间，而总共有n个输入数字，故总的时间效率就是O(nlogk)。
