剑指offer第四章

剑指offer第四章

1.二叉树的镜像

二叉树的镜像：输入一个二叉树，输出它的镜像

分析：求树的镜像过程其实就是在遍历树的同时，交换非叶结点的左右子结点。

求镜像的过程：先前序遍历这棵树的每个结点，如果遍历到的结点有子结点，交换它的两个子结点，当交换完所有非叶子结点的左右子结点之后，就得到了树的镜像。

 /*
 struct TreeNode {
     int val;
     struct TreeNode *left;
     struct TreeNode *right;
     TreeNode(int x) :
             val(x), left(NULL), right(NULL) {
     }
 };*/
 class Solution {
 public:
     void Mirror(TreeNode *pRoot)
     {
         if(pRoot==NULL)//二叉树为空
             return;
         if(pRoot->left==NULL&&pRoot->right==NULL)//二叉树只有一个结点
             return;

         //交换左右结点
         TreeNode *pTemp=pRoot->left;
         pRoot->left=pRoot->right;
         pRoot->right=pTemp;

         if(pRoot->left) //递归求左子树的镜像
             Mirror(pRoot->left);
         if(pRoot->right)//递归求右子树的镜像
             Mirror(pRoot->right);
     }
 };

2.顺时针打印矩阵

分析：

/*解题思路：顺时针打印就是按圈数循环打印，一圈包含两行或者两列，在打印的时候会出现某一圈中只包含一行，

要判断从左向右打印和从右向左打印的时候是否会出现重复打印，

同样只包含一列时，要判断从上向下打印和从下向上打印的时候是否会出现重复打印的情况*/

 class Solution {
 public:
     vector<int> printMatrix(vector<vector<int> > matrix) {
         vector<int>res;
         res.clear();
         int rows=matrix.size();//行数
         int columns=matrix[].size();//列数
         //计算打印的圈数
         int circle=((rows<columns?rows:columns)-)/+;//圈数
         for(int i=;i<circle;i++){
             //从左向右打印
             for(int j=i;j<columns-i;j++)
                 res.push_back(matrix[i][j]);
             //从上往下的每一列数据
             for(int k=i+;k<rows-i;k++)
                 res.push_back(matrix[k][columns--i]);
             //判断是否会重复打印(从右向左的每行数据)
             for(int m=columns-i-;(m>=i)&&(rows-i-!=i);m--)
                 res.push_back(matrix[rows-i-][m]);
             //判断是否会重复打印(从下往上的每一列数据)
             for(int n=rows-i-;(n>i)&&(columns-i-!=i);n--)
                 res.push_back(matrix[n][i]);}
         return res;
     }
 };

3.包含min函数的栈

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

 /*
 * 1.dataStack为存储数据的栈，minStack为存储最小值的栈；
 * 2.push的时候将value值与minStack中的top值比较，小则minStack push value，大则push top值
 */
 class Solution {
 public:
     stack<int> dataStack, minStack;//定义两个栈，一个数据栈，一个最小值的辅助栈
     void push(int value)
     {
         dataStack.push(value);//将数据进行压入数据栈
         if (minStack.empty()) //如果辅助栈尾空，将数据压入辅助栈
         {
             minStack.push(value);
         }
         else//如果数据小于min，数据压入辅助栈，否则最小值压入辅助栈
         {
             int min = minStack.top();
             value<=min?minStack.push(value):minStack.push(min);
         }

     }
     void pop() //出栈
     {
         dataStack.pop();//数据栈出栈
         minStack.pop();//辅助栈出栈
     }
     int top() //栈顶
     {
         return  dataStack.top();
     }
     int min() //取最小
     {
         return minStack.top();
     }
 };

4、栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

分析：

可以找到判断一个序列是不是栈的弹出序列的规律：如果下一个弹出的数字刚好是栈顶数字，那么直接弹出。

    如果下一个弹出的数字不在栈顶，我们把压栈序列中还没有入栈的数字压入辅助栈，直到把下一个需要弹出的数字压入栈顶为止。

    如果把所有的数字都压入栈仍然没有找到下一个弹出的数字，那么该序列不可能是一个弹出序列。

/*C++

模拟堆栈操作：将原数列依次压栈，栈顶元素与所给出栈队列相比，如果相同则出栈，

如果不同则继续压栈，直到原数列中所有数字压栈完毕。

检测栈中是否为空，若空，说明出栈队列可由原数列进行栈操作得到。否则，说明出栈队列不能由原数列进行栈操作得到。

*/

 class Solution {
 public:
     bool IsPopOrder(vector<int> pushV,vector<int> popV)
     {
         if(pushV.empty() || popV.empty() || pushV.size()!=popV.size())//如果压入序列或者弹出序列为空、或者压入序列和弹出序列大小不等
             return false;
         stack<int> s;
         int j=;
         for(int i=;i<pushV.size();++i)
         {
             s.push(pushV[i]);
             while(!s.empty()&&s.top()==popV[j])
             {
                 s.pop();
                 ++j;
             }
         }
         if(s.empty())
             return true;
         return false;
     }
 };

5.从上往下打印二叉树从上往下打印出二叉树的每个节点，同层节点从左至右打印。

分析：

每一次打印一个结点的时候，如果该结点有子结点，则把该结点的子结点放入一个队列的末尾。

接下来到队列的头部去除最早进入队列的结点，重复前面的打印操作，直到队列中所有的结点都被打印出来为止。

 class Solution {
 public:
     vector<int> PrintFromTopToBottom(TreeNode *root)
     {
         queue<TreeNode*> q;
         q.push(root);
         vector<int> r;
         while(!q.empty())
         {
             root = q.front();
             q.pop();
             if(!root)
                 continue;
             r.push_back(root -> val);
             q.push(root -> left);
             q.push(root -> right);
         }
         return r;
     }
 };

6.二叉搜索树的后序遍历序列输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。

分析：

在后序遍历得到的序列中，最后一个数字是树的根结点的值。

数组中前面的数字可以分为两部分：第一部分是左子树结点的值，他们都比根结点的值小，第二部分是右子树结点的值，他们的值都比根结点的值大。

//1、确定root； 

//2、遍历序列（除去root结点），找到第一个大于root的位置，则该位置左边为左子树，右边为右子树； 

//3、遍历右子树，若发现有小于root的值，则直接返回false； 

//4、分别判断左子树和右子树是否仍是二叉搜索树（即递归步骤1、2、3）。 

 class Solution {
 public:
     bool VerifySquenceOfBST(vector<int> sequence) {
         vector<int> leftTree,rightTree;
         int root; // 根结点
         if(sequence.empty())
             return false;
         int index = ; // 标记左右子树界限
         int len = sequence.size();
         root = sequence[len-];
         int i=;
         for(;i<len-;++i)
         {
             if(sequence[i]>root)
                 break; // 找到第一个大于根结点的位置，则左边为左子树，右边为右子树
         }
         for(int j=i;j<len-;++j) // 循环时去除root，因此为len-1
         {
             if(sequence[j]<root)
                 return false; // 有一个小于root，则返回false
         }

         if(i!=)
         {
             // 即有左子树
             for(int m=;m<i;++m)
             {
                 leftTree.push_back(sequence[m]);
             }
         }
         if(i!=len-)
         {
             for(int j=i;j<len-;++j)
             {
                 rightTree.push_back(sequence[j]);
             }
         }

         bool left = true,right = true; // 看左右子树是否是二叉搜索树
         if(leftTree.size()>) VerifySquenceOfBST(leftTree);
         if(rightTree.size()>) VerifySquenceOfBST(rightTree);

         return (left&&right);
     }
 };

7.二叉树中和为某一值的路径： 注：路径是从根结点出发到叶结点。

//非递归版本

//思路：

//1.按先序遍历把当前节点cur的左孩子依次入栈同时保存当前节点，每次更新当前路径的和sum；

//2.判断当前节点是否是叶子节点以及sum是否等于expectNumber，如果是，把当前路径放入结果中。

//3.遇到叶子节点cur更新为NULL，此时看栈顶元素，如果栈顶元素的把栈顶元素保存在last变量中，同时弹出栈顶元素，当期路径中栈顶元素弹出，

//sum减掉栈顶元素，这一步骤不更改cur的值；

//4.如果步骤3中的栈顶元素的右孩子存在且右孩子之前没有遍历过，当前节点cur更新为栈顶的右孩子，此时改变cur=NULL的情况。

 /*
 struct TreeNode {
     int val;
     struct TreeNode *left;
     struct TreeNode *right;
     TreeNode(int x) :
             val(x), left(NULL), right(NULL) {
     }
 };*/
 class Solution {
 public:
     vector<vector<int> > FindPath(TreeNode* root,int expectNumber)
     {
          vector<vector<int> > res;
         if (root == NULL)
             return res;
         stack<TreeNode *> s;
         s.push(root);
         int sum = ; //当前和
         vector<int> curPath; //当前路径
         TreeNode *cur = root; //当前节点
         TreeNode *last = NULL; //保存上一个节点
         while (!s.empty())
         {
             if (cur == NULL)
             {
                 TreeNode *temp = s.top();
                 if (temp->right != NULL && temp->right != last)
                 {
                     cur = temp->right; //转向未遍历过的右子树
                 }
                 else
                 {
                     last = temp; //保存上一个已遍历的节点
                     s.pop();
                     curPath.pop_back(); //从当前路径删除
                        sum -= temp->val;
                 }
             }
             else
             {
                 s.push(cur);
                 sum += cur->val;
                 curPath.push_back(cur->val);
                 if (cur->left == NULL && cur->right == NULL && sum == expectNumber)
                 {
                     res.push_back(curPath);
                 }
                 cur = cur->left; //先序遍历，左子树先于右子树
             }
         }
         return res;

     }
 };

8.复杂链表的复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。

（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

 /*
 struct RandomListNode {
     int label;
     struct RandomListNode *next, *random;
     RandomListNode(int x) :
             label(x), next(NULL), random(NULL) {
     }
 };
 */
 class Solution {
 public:
     void CloneNodes(RandomListNode* pHead)
         {
         RandomListNode* pNode=pHead;
         while(pNode!=NULL){
             RandomListNode* pCloned=new RandomListNode();
             pCloned->label=pNode->label;
             pCloned->next=pNode->next;
             pCloned->random=NULL;

             pNode->next=pCloned;
             pNode=pCloned->next;
         }
     }

     void ConnectSiblingNodes(RandomListNode* pHead)
         {
         RandomListNode* pNode=pHead;
         while(pNode!=NULL){
             RandomListNode* pCloned=pNode->next;
             if(pNode->random!=NULL)
                 {
                 pCloned->random=pNode->random->next;
             }
             pNode=pCloned->next;
         }
     }

     RandomListNode* ReconnectNodes(RandomListNode* pHead)
         {
         RandomListNode* pNode=pHead;
         RandomListNode* pClonedHead=NULL;
         RandomListNode* pClonedNode=NULL;

         if(pNode!=NULL)
             {
             pClonedHead=pClonedNode=pNode->next;
             pNode->next=pClonedNode->next;
             pNode=pNode->next;
         }

         while(pNode!=NULL)
             {
             pClonedNode->next=pNode->next;
             pClonedNode=pClonedNode->next;
             pNode->next=pClonedNode->next;
             pNode=pNode->next;
         }
         return pClonedHead;
     }
     RandomListNode* Clone(RandomListNode* pHead)
     {
         CloneNodes(pHead);
         ConnectSiblingNodes(pHead);
         return ReconnectNodes(pHead);
     }
 };

9.二叉搜索树与双向链表

输入一颗二叉搜索树，将该二叉搜索树转换成一个排序的双向链表（要求不能创建新的结点，只能调整树中结点指针的指向）

分析：在搜索二叉树中，左子结点的值总是小于父节点的值，右子节点的值总是大于父节点的值。因此我们在转换成排序双向链表时，原先指向左子节点的指针调整为链表中指向前一个结点的指针，原先指向右子节点的指针调整为链表中指向后一个结点指针。

 /*
 struct TreeNode {
     int val;
     struct TreeNode *left;
     struct TreeNode *right;
     TreeNode(int x) :
             val(x), left(NULL), right(NULL) {
     }
 };*/
 class Solution {
 public:
     void ConvertNode(TreeNode* pNode,TreeNode** pLastNodeInList)
         {
         if(pNode==NULL)
             return;
         TreeNode *pCurrent=pNode;
         if(pCurrent->left!=NULL)
             ConvertNode(pCurrent->left,pLastNodeInList);
         pCurrent->left=*pLastNodeInList;
         if(*pLastNodeInList!=NULL)
             (*pLastNodeInList)->right=pCurrent;
         *pLastNodeInList=pCurrent;
         if(pCurrent->right!=NULL)
             ConvertNode(pCurrent->right,pLastNodeInList);
     }
     TreeNode* Convert(TreeNode* pRootOfTree)
     {
         TreeNode *pLastNodeInList=NULL;
         ConvertNode(pRootOfTree,&pLastNodeInList);
         TreeNode *pHeadOfList=pLastNodeInList;
         while(pHeadOfList!=NULL&&pHeadOfList->left!=NULL)
             pHeadOfList=pHeadOfList->left;
         return pHeadOfList;
     }
 };

10.字符串的排列

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

输入描述:输入一个字符串,长度不超过9(可能有字符重复),字符只包括大小写字母。

递归思路：分为两步，首先求所有可能出现在第一个位置的字符，即把第一个字符和后面所有字符交换。第二步固定第一个字符，求后面所有字符的排列。

仍然分为两部分：后面字符的第一个字符，以及这个字符之后的所有字符。然后把第一个字符逐一和它后面字符交换。

 class Solution {
 public:
     set<string> res;
     void fun(string str, int pos)
     {
         if (pos == str.length())
         {
             res.insert(str);
             return;
         }
         for (int i = pos; i < str.length(); ++i)
         {
             swap(str[i], str[pos]);
             fun(str, pos + );
             swap(str[i], str[pos]);
         }
     }
     vector<string> Permutation(string str) {
         res.clear();
         vector<string> st;
         if (str.length() == )
             return st;
         fun(str, );
         set<string>::iterator it;
         for (it = res.begin(); it != res.end(); ++it)
             st.push_back(*it);
         return st;
     }
 };