牛客剑指offer(持续更新~)

第一题：二维数组的查找

题目描述

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

 

题解：

由于二维数组数从左到右递增，从上到下递增，那么，我们可以考虑从左下角查找，如果val大于array[i][j]的话，j++,如果小于a[i][j]的话,i--,否则输出true表示找到了val;

如果到最后都没有找到，说明不存在该元素，返回false:表示没有该元素。

 

参考代码:

 class Solution {
 public:
   bool Find(int target, vector<vector<int> > array) {
     // array是二维数组，这里没做判空操作
     int rows = array.size();
     int cols = array[].size();
     int i=rows-,j=;//左下角元素坐标
     while(i>= && j<cols){//使其不超出数组范围
       if(target<array[i][j])
         i--;//查找的元素较少，往上找
       else if(target>array[i][j])
         j++;//查找元素较大，往右找
       else
         return true;//找到
     }
     return false;
   }
 };

C++

第二题：替换空格

题目描述

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

 

题解：

我们先统计出来空格的数量，计算出替换后的字符串的长度，然后从后往前替换即可。

 

参考代码：

 public class Solution {
     public String replaceSpace(StringBuffer str) {
         return str.toString().replaceAll("\\s", "%20");
     }
 }

第三题：从尾到头打印字符

题目描述

输入一个链表，按链表从尾到头的顺序返回一个ArrayList。

题解：

每次插入到vector的头部直到head==NULL;

参考代码：

 /**
 *  struct ListNode {
 *        int val;
 *        struct ListNode *next;
 *        ListNode(int x) :
 *              val(x), next(NULL) {
 *        }
 *  };
 */
 class Solution {
 public:
     vector<int> printListFromTailToHead(ListNode* head)
     {
         vector<int> ans;
         while(head!=NULL)
         {
             ans.insert(ans.begin(),head->val);
             head=head->next;
         }
         return ans;

     }
 };

C++

第四题：重建二叉树

题目描述

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

 

题解：

　　例如：前序遍历 GDAFEMHZ

　　　　　中序遍历 ADEFGHMZ

 　　则根据前序遍历规则知道树根为G,那么我们在中序遍历中找到根，那么根G 左边的一定是该根的左子树的节点，根右边的元素一定是根右子树的节点；

　　我们这样递归即可得到原二叉树。

参考代码：

 /**
  * Definition for binary tree
  * struct TreeNode {
  *     int val;
  *     TreeNode *left;
  *     TreeNode *right;
  *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  * };
  */
 class Solution {
 public:
     TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
         if(pre.size()==||pre.size()!=vin.size()) return NULL;

         vector<int> pre_left,pre_right;
         vector<int> inl,inr;
         TreeNode *node=new TreeNode(pre[]);
         int rootindex;
         //找到中序遍历数组中根的位置
         for(int i=;i<vin.size();++i)
         {
             if(vin[i]==pre[])
             {
                 rootindex=i;
                 break;
             }
         }
         //左子树元素
         for(int i=;i<rootindex;++i)
         {
             inl.push_back(vin[i]);
             if(i+<pre.size()) pre_left.push_back(pre[i+]);
         }
         //右子树元素
         for(int i=rootindex+;i<vin.size();++i)
         {
             inr.push_back(vin[i]);
             pre_right.push_back(pre[i]);
         }

         node->left=reConstructBinaryTree(pre_left,inl);
         node->right=reConstructBinaryTree(pre_right,inr);

         return node;
     }
 };

C++

 /**
  * Definition for binary tree
  * public class TreeNode {
  *     int val;
  *     TreeNode left;
  *     TreeNode right;
  *     TreeNode(int x) { val = x; }
  * }
  */
 public class Solution {
     public TreeNode reConstructBinaryTree(int [] pre,int [] in)
     {
         TreeNode node=func(pre,0,pre.length-1,in,0,in.length-1);
         return node;
     }
     public TreeNode func(int [] pre,int pre_start,int pre_end,int [] in,int in_start,int in_end)
     {
         if(pre_start>pre_end||in_start>in_end)
         {
             return null;
         }
         TreeNode node = new TreeNode(pre[pre_start]);

         for(int i=in_start;i<=in_end;++i)
         {
             if(in[i]==pre[pre_start])
             {
                 node.left=func(pre,pre_start+1,pre_start+i-in_start,in,in_start,i-1);
                 node.right=func(pre,pre_start+i-in_start+1,pre_end,in,i+1,in_end);

                 break;
             }
         }
         return node;
     }
 }

Java

第五题：用两个栈来实现一个队列

题目描述

用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型。

 

题解：

对于push操作，我们直接放入stack1中，对于pop操作，我们先判断stack2是否空，不空就输出stack2的栈顶元素即可；为空就把stack1中的元素放入到stack2中然后输出stack2的栈顶元素；

参考代码：

 class Solution
 {
 public:
     void push(int node) {
         stack1.push(node);
     }

     int pop() {
         int ans;
         if(!stack2.empty())
             ans=stack2.top(),stack2.pop();
         else
         {
             while(!stack1.empty())
             {
                 stack2.push(stack1.top());
                 stack1.pop();
             }
             ans=stack2.top(),stack2.pop();
         }
         return ans;
     }

 private:
     stack<int> stack1;
     stack<int> stack2;
 };

C++

 import java.util.Stack;

 public class Solution {
     Stack<Integer> stack1 = new Stack<Integer>();
     Stack<Integer> stack2 = new Stack<Integer>();

     public void push(int node) {
         stack1.push(node);
     }

     public int pop() {
         if(!stack2.empty())
             return stack2.pop();
         else
         {
                while(!stack1.empty())
                {
                    stack2.push(stack1.pop());
                 }
             return stack2.pop();
         }
     }
 }

Java

第六题：旋转数组最小的数字

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。
输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。
例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。
NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

 

题解：

就是找数组的最小值。

参考代码：

 class Solution {
 public:
     int minNumberInRotateArray(vector<int> array) {
         if(!array.size()) return ;
         int ans=array[];
         for(int i=;i<array.size();++i)
             ans=min(ans,array[i]);
         return ans;
     }
 };

C++

 import java.util.ArrayList;
 public class Solution {
     public int minNumberInRotateArray(int [] array) {
         if(array.length==0) return 0;
         int ans=array[0];
         for(int i=1;i<array.length;++i)
         {
             if(array[i]<ans) ans=array[i];
         }
         return ans;

     }
 }

Java

第七题：斐波那契数列

题目描述

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

n<=39

题解：

a[n]=a[n-1]+a[n-2];

参考代码：

 class Solution {
 public:
     int Fibonacci(int n) {
         int a=,b=;
         if(n==) return ;
         if(n==||n==) return ;
         for(int i=;i<=n;++i)
         {
             int c=a;
             a=a+b;
             b=c;
         }
         return a;
     }
 };

C++

 public class Solution {
     public int Fibonacci(int n) {
         int a=1,b=1;
         if(n==0) return 0;
         if(n==1||n==2) return 1;
         for(int i=3;i<=n;++i)
         {
             int c=a;
             a=a+b;
             b=c;
         }
         return a;
     }
 }

Java

第八题：跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

题解：

本质也是斐波那契数列

参考代码：

 class Solution {
 public:
     int jumpFloor(int number) {
         if(number==) return ;
         if(number==) return ;
         return jumpFloor(number-)+jumpFloor(number-);
     }
 };

C++

 public class Solution {
     public int JumpFloor(int number) {
         if(number==1) return 1;
         if(number==2) return 2;
         return JumpFloor(number-1)+JumpFloor(number-2);
     }
 }

Java

第九题：变态跳台阶

题目描述

一只青蛙一次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。求该青蛙跳上一个n级的台阶总共有多少种跳法。

 

题解：

和斐波那契数列推导一样，这个推一下吧。

用Fib(n)表示青蛙跳上n阶台阶的跳法数，青蛙一次性跳上n阶台阶的跳法数1(n阶跳)，设定Fib(0) = 1；

当n = 1 时，只有一种跳法，即1阶跳：Fib(1) = 1;

当n = 2 时，有两种跳的方式，一阶跳和二阶跳：Fib(2) = Fib(1) + Fib(0) = 2;

当n = 3 时，有三种跳的方式，第一次跳出一阶后，后面还有Fib(3-1)中跳法；第一次跳出二阶后，后面还有Fib(3-2)中跳法；第一次跳出三阶后，后面还有Fib(3-3)中跳法

当n = n 时，共有n种跳的方式，第一次跳出一阶后，后面还有Fib(n-1)中跳法；第一次跳出二阶后，后面还有Fib(n-2)中跳法…第一次跳出n阶后，后面还有 Fib(n-n)中跳法.

Fib(n) = Fib(n-1)+Fib(n-2)+Fib(n-3)+……….+Fib(n-n)=Fib(0)+Fib(1)+Fib(2)+…….+Fib(n-1)
又因为Fib(n-1)=Fib(0)+Fib(1)+Fib(2)+…….+Fib(n-2)

两式相减得：Fib(n) = 2*Fib(n-1) n >= 2

参考代码：

 class Solution {
 public:
     int jumpFloorII(int number) {
        if(number==) return ;
        int ans=;
         for(int i=;i<number;++i)
             ans=ans*;
         return ans;
     }
 };

C++

 public class Solution {
     public int JumpFloorII(int number) {
         if(number==0) return 0;
        int ans=1;
         for(int i=1;i<number;++i)
             ans=ans*2;
         return ans;
     }
 }

Java

第十题：矩形覆盖

题目描述

我们可以用2*1的小矩形横着或者竖着去覆盖更大的矩形。请问用n个2*1的小矩形无重叠地覆盖一个2*n的大矩形，总共有多少种方法？

 

题解：

n=1 ：只有横放一个矩形一种解决办法
n=2 ：有横放一个矩形，竖放两个矩形两种解决办法
n=3 ：n=2的基础上加1个横向，n=1的基础上加2个竖向
n=4：n=3的基础上加1个横向，n=2的基础上加2个竖向

...

n=n ：n = f(n-1) + f(n-2)

参考代码：

 class Solution {
 public:
     int rectCover(int n) {
         if(n==) return ;
         if(n==) return ;
         if(n==) return ;
         int a=,b=,c;
         for(int i=;i<=n;++i)
         {
             c=a;
             a=a+b;
             b=c;
         }
         return a;
     }
 };

C++

 public class Solution {
     public int RectCover(int n) {
         if(n==) return ;
         if(n==) return ;
         if(n==) return ;
         int a=,b=,c;
         for(int i=;i<=n;++i)
         {
             c=a;
             a=a+b;
             b=c;
         }
         return a;
     }
 }

Java

第十一题：二进制中一的个数

题目描述

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

题解：

每次n&(n-1)即可以把最后一个一取出来；

参考代码：

 class Solution {
 public:
      int  NumberOf1(int n) {
         int ans=;
          while(n)
          {
              n&=(n-);
              ans++;
         }
          return ans;
      }
 };

C++

 public class Solution {
     public int NumberOf1(int n) {
         int ans=;
          while(n!=)
          {
              n&=(n-);
              ans++;
         }
          return ans;
     }
 }

Java

第十二题：数值的整数次方

题目描述

给定一个double类型的浮点数base和int类型的整数exponent。求base的exponent次方。

 

保证base和exponent不同时为0

题解：

注意正负号，快速幂即可；

 

参考代码：

 class Solution {
 public:
     double Power(double b, int e) {
         if(e==) return ;
         if(e==) return b;
         double res=;
         int tmp=;
         if(e<) e=-e,tmp=;

         while(e!=)
        {
            if(e&) res=res*b;
            b=b*b;
            e>>=;
        }
         if(tmp==) res=1.0/res;

         return res;
     }
 };

C++

 public class Solution {
     public double Power(double b, int ee) {
         if(ee==0) return 1;
         if(ee==1) return b;
         double res=1;
         int tmp=0;
         if(ee<0)
         {
             ee=-ee;
             tmp=1;
         }

         while(ee!=0)
        {
            if((ee&1)==1) res=res*b;
            b=b*b;
            ee>>=1;
        }
         if(tmp==1) res=1.0/res;

         return res;
   }
 }

Java

第十三题：调整该数组中数字的顺序

题目描述

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

题解：

我们用 i记录奇数的位置，j表示偶数的左边界，每次遇到一个奇数，就把j~i-1的偶数向后移一位，然后把这个奇数放到第j个位置上，j++;

参考代码：

 class Solution {
 public:
     void reOrderArray(vector<int> &array) {
         vector<int> t1,t2;
         int i,j;
         for(i=;i<array.size();i++){
             if(array[i]%!=){
                 t1.push_back(array[i]);
             }else{
                 t2.push_back(array[i]);
             }
         }
         for(i=;i<t1.size();i++){
             array[i]=t1[i];
         }
         for(j=;j<t2.size()&&i<array.size();j++,i++){
             array[i]=t2[j];
         }
     }
 };

C++

 public class Solution {
     public void reOrderArray(int[] array) {
         int j = 0;
         for (int i = 0; i < array.length; i++) {
             if (array[i] % 2 == 1) {
                 //如果是奇数的话
                 if (i != j) {
                     int temp = array[i];
                     int k = i;
                     for (k = i; k > j; k--) {
                         array[k] = array[k - 1];
                     }
                     array[k] = temp;

                 }
                 j++;
             }
         }
     }
 }

Java

第十四题：输出链表中倒数第k个结点

题目描述

输入一个链表，输出该链表中倒数第k个结点。

题解：

用快慢指针法，快指针先走k-1步，然后快慢指针一起移动即可。

参考代码：

 /*
 struct ListNode {
     int val;
     struct ListNode *next;
     ListNode(int x) :
             val(x), next(NULL) {
     }
 };*/
 class Solution {
 public:
     ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
         ListNode* p=pListHead;
         ListNode* q=pListHead;
         int i=;
         for(;p!=NULL;i++)
         {
             if(i>=k)
                 q=q->next;
             p=p->next;
         }
         if(i<k)
             return NULL;
         else
             return q;
     }
 };

C++

 /*
 public class ListNode {
     int val;
     ListNode next = null;

     ListNode(int val) {
         this.val = val;
     }
 }*/
 public class Solution {
     public ListNode FindKthToTail(ListNode pListHead,int k) {
         ListNode p=pListHead;
         ListNode q=pListHead;
         int i=0;
         for(;p!=null;i++)
         {
             if(i>=k)
                 q=q.next;
             p=p.next;
         }
         if(i<k)
             return null;
         else
             return q;
     }
 }

Java

第十五题：反转链表

题目描述

输入一个链表，反转链表后，输出新链表的表头。

 

题解：

记录3个指针，pre,now,next

pre:表示now的前一个节点，now:表示当前节点，next：表示now的下一个节点（可能为NULL）;

每次让

next=now->next;

now->next=pre;

pre=now;

now=next;

结束标志为 now==NULL;

最后输出指针now就行了。

参考代码：

 /*
 struct ListNode {
     int val;
     struct ListNode *next;
     ListNode(int x) :
             val(x), next(NULL) {
     }
 };*/
 class Solution {
 public:
     ListNode* ReverseList(ListNode* pHead) {
        ListNode *reverse=NULL;
        ListNode *node=pHead;
        ListNode *pre=NULL;
        while(node!=NULL)
        {
             ListNode *next=node->next;
             if(next==NULL)
                 reverse=node;
             node->next=pre;
             pre=node;
             node=next;
         }
         return reverse;
     }
 };

C++

 public class Solution {
     public ListNode ReverseList(ListNode head) {
         ListNode pre = null;
         ListNode now = head;
         ListNode aft = null;
         while(now != null){
             aft = now.next;
             now.next=pre;
             pre = now;
             now = aft;
         }
         return pre;
     }
 }

Java

第十六题 反转链表

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 热度指数：662243

本题知识点： 链表

算法知识视频讲解

题目描述

输入一个链表，反转链表后，输出新链表的表头。

题解：

　　记录3个指针即可。

参考代码：

public class Solution {
    public ListNode ReverseList(ListNode head) {
        ListNode pre = null;
        ListNode now = head;
        ListNode aft = null;
        while(now != null){
            aft = now.next;
            now.next=pre;
            pre = now;
            now = aft;
        }
        return pre;
    }
}

Java

第十七题 合并两个有序链表

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 热度指数：641239

本题知识点： 链表

算法知识视频讲解

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

 

题解：

新建一个链表头。然后依次将两个链表中的元素加入即可，判断一下大小。

 

参考代码：

public class Solution {
    public ListNode Merge(ListNode l1,ListNode l2) {
         ListNode l3=new ListNode(0);
        ListNode l4=l3;
        while(l1!=null && l2!=null)
        {
            if(l1.val<=l2.val)
            {
                l3.next=l1;
                l1=l1.next;
            }
            else
            {
                l3.next=l2;
                l2=l2.next;
            }
            l3=l3.next;
        }
        if(l1!=null) l3.next=l1;
        else if(l2!=null) l3.next=l2;
        return l4.next;
    }
}

Java

第十八题 树的子结构

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 热度指数：617491

本题知识点： 二叉树

算法知识视频讲解

题目描述

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

 

题解：

对于树B，要么和root本身相同，要么和root.left相同，要么和root.right相同。否则就不是树A的子结构。

递归判断即可。

 

参考代码：

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {

    public boolean IsSubtree(TreeNode a,TreeNode b)
    {
        if(b==null) return true;
        if(a==null) return false;
        if(a.val==b.val)
        {
            return IsSubtree(a.left,b.left) && IsSubtree(a.right,b.right);
        }
        else return false;
    }

    public boolean HasSubtree(TreeNode root1,TreeNode root2)
    {
        if(root2==null||root1==null) return false;

        return IsSubtree(root1,root2)||HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);
    }
}

Java

第十九题 二叉树镜像

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 热度指数：355640

本题知识点： 树

算法知识视频讲解

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

输入描述:

二叉树的镜像定义：源二叉树
    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9 11
    	镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5

题解：

水题，递归将左右子树交换即可。

参考代码：

/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    public void Mirror(TreeNode root)
    {
        if(root==null) return ;
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        Mirror(root.left);
        Mirror(root.right);
    }
}

Java

第二十题 顺时针打印矩阵

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 热度指数：652806

本题知识点： 数组

算法知识视频讲解

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

 

题解：

记录左右上下边界，然后依次输出（注意判断是否重合，左右，上下）。

参考代码：

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix)
    {
        int row = matrix.size();
        if(row==) return {};
        int col = matrix[].size();
        vector<int> res;
        if (row ==  || col == )  return res;

        // 定义四个关键变量，表示左上和右下的打印范围
        int left = , top = , right = col - , bottom = row - ;
        while (left <= right && top <= bottom)
        {
            // left to right
            for (int i = left; i <= right; ++i)  res.push_back(matrix[top][i]);
            // top to bottom
            for (int i = top + ; i <= bottom; ++i)  res.push_back(matrix[i][right]);
            // right to left
            if (top != bottom)
            for (int i = right - ; i >= left; --i)  res.push_back(matrix[bottom][i]);
            // bottom to top
            if (left != right)
            for (int i = bottom - ; i > top; --i)  res.push_back(matrix[i][left]);
            left++,top++,right--,bottom--;
        }
        return res;
    }
};

C++

第二十一题 包含min函数的栈

时间限制：C/C++ 1秒，其他语言2秒 空间限制：C/C++ 32M，其他语言64M 热度指数：381435

本题知识点： 栈

算法知识视频讲解

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

 

题解：使用两个栈st,st2.st里面放元素，st2是个单调栈，保存当前栈st中的最小元素。

 

参考代码：

class Solution {
public:
    stack<int> st,st2;

    void push(int value)
    {
        st.push(value);
        if(st2.empty() || (value<st2.top()))
            st2.push(value);
    }
    void pop()
    {
        if(!st.empty())
        {
            int val=st.top();
            st.pop();
            if(val==st2.top())
                st2.pop();
        }
    }
    int top()
    {
        if(!st.empty())
            return st.top();
    }
    int min()
    {
        if(!st2.empty())
            return st2.top();
    }
};

C++

第二十二题 栈的压入和弹出

题目描述

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

题解：我们模拟栈的压入，如果当前栈顶元素等于出栈的最前面的元素，则出栈，后移出栈数组的最前面元素，知道不相等，或则入栈数组元素用完。左后判断栈是否为空即可。

参考代码：

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV)
    {
        stack<int> st;
        int id=;
        for(int i=;i<popV.size();++i)
        {
            while(st.empty()||st.top()!=popV[i])
            {
                st.push(pushV[id++]);
                if(id>pushV.size())
                    return false;
            }
            st.pop();
        }
        if(st.empty()) return true;
        else return false;
    }
};

C++

第二十三题 从上往下打印二叉树

题目描述

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

 

题解：用队列即可。

 

参考代码：

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/

class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root)
    {
        vector<int> ans;
        if(root==NULL) return ans;
        queue<TreeNode*> q;

        q.push(root);
        int cnt=;
        while(!q.empty())
        {
            TreeNode* u=q.front();q.pop();
            ans.push_back(u->val);
            if(u->left) q.push(u->left);
            if(u->right) q.push(u->right);
        }
        return ans;
    }
};

C++

第二十四题 二叉搜索树的后序遍历序列

题目描述

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

 

题解：二叉搜索树的性质：左子树的元素都比根小，右子树的元素都比根大。这样，知道最后一个元素一定是根，然后我们对每一层找到第一个比根大的元素，然后判断后面的是否都比根大，如果有比根小的，则返回false，否则继续判断左右子树，返回true，递归判断。

 

参考代码：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        return bst(sequence,,sequence.size()-);
    }
    bool bst(vector<int> sequence,int begin,int end)
    {
        if(sequence.empty()||begin>end)
            return false;
        int root=sequence[end];
        int i=begin;
        for(;i<end;++i)
            if(sequence[i]>root) break;
        for(int j=i;j<end;++j)
            if(sequence[j]<root) return false;
        bool left=true;
        if(i>begin)
            left=bst(sequence,begin,i-);
        bool right=true;
        if(i<end-)
            right=bst(sequence,i,end-);
        return left&&right;
    }
};

C++

 

 

 

 

 

未完待续~