第一题：二维数组的查找

题目描述

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

题解：

由于二维数组数从左到右递增，从上到下递增，那么，我们可以考虑从左下角查找，如果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++

未完待续~

牛客剑指offer(持续更新~)的更多相关文章

链表分割——牛客剑指offer
题目描述: 编写代码,以给定值x为基准将链表分割成两部分,所有小于x的结点排在大于或等于x的结点之前给定一个链表的头指针 ListNode pHead,请返回重新排列后的链表的头指针.注意:分割以后 ...
链表中环的入口结点——牛客剑指offer
题目描述: 给一个链表,若其中包含环,请找出该链表的环的入口结点,否则,输出null. 题目分析: 从上图中可以看出,环的入口结点和其他结点的区别:环的入口结点是有两个指针指向的,其他结点除了头结点都 ...
删除链表中重复的结点——牛客剑指offer
题目描述: 在一个排序的链表中,存在重复的结点,请删除该链表中重复的结点,重复的结点不保留,返回链表头指针. 例如,链表1->2->3->3->4->4->5 处理 ...
从尾到头打印列表——牛客剑指offer
题目描述输入一个链表,按链表值从尾到头的顺序返回一个ArrayList. 解题思路思路1: 顺序遍历链表,取出每个结点的数据,插入list中. 由于要求list倒序存储链表中的数据,而我们是顺序取 ...
二维数组中的查找——牛客剑指offer
题目描述: 在一个二维数组中(每个一维数组的长度相同),每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序.请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整 ...
牛客剑指Offer-数字在升序数组中出现的次数
题目统计一个数字在升序数组中出现的次数. 示例1 输入 [1,2,3,3,3,3,4,5],3 返回值 4 题解第一种最简单的方法是O(n)复杂度.遍历数组统计结果. public int Get ...
牛客网剑指offer刷题总结
二维数组中的查找: 题目描述:在一个二维数组中,每一行都按照从左到右递增的顺序排序,每一列都按照从上到下递增的顺序排序.请完成一个函数,输入这样的一个二维数组和一个整数,判断数组中是否含有该整数. 两 ...
LeetCode题解汇总（包括剑指Offer和程序员面试金典，持续更新）
LeetCode题解汇总(持续更新,并将逐步迁移到本博客列表中) LeetCode题解分类汇总(包括剑指Offer和程序员面试金典) 剑指Offer 序号题目难度 03 数组中重复的数字简单 0 ...
LeetCode题解分类汇总（包括剑指Offer和程序员面试金典，持续更新）
LeetCode题解汇总(持续更新,并将逐步迁移到本博客列表中) 剑指Offer 数据结构链表序号题目难度 06 从尾到头打印链表简单 18 删除链表的节点简单 22 链表中倒数第k个节点 ...

随机推荐

关于BootStrap的相关介绍
一.Bootstrap Bootstrap的官网:www.bootcss.com 1.响应式布局 Responsive web page 响应式/自适应的网页可以根据浏览器设备的不同(pc,pad, ...
fpm打包神奇rpm包升级python2.7.16
fpm打包神器参考文档:https://www.cnblogs.com/flintlovesam/p/6594635.html FPM的安装:安装ruby环境和gem命令: yum -y instal ...
Mybatis实现数据的增删改查
Mybatis实现数据的增删改查 1.项目结构(使用maven创建项目) 2.App.java package com.GetcharZp.MyBatisStudy; import java.io.I ...
python3.7.1安装Scrapy爬虫框架
python3.7.1安装Scrapy爬虫框架环境:win7(64位), Python3.7.1(64位) 一.安装pyhthon 详见Python环境搭建:http://www.runoob.co ...
分析facebook的AsyncDisplayKit框架，async-display使用async-transaction
上一篇<分析facebook的AsyncDisplayKit框架中的Transaction的工作原理>介绍了fb的asdk的异步事务ASAsyncTransaction,本篇介绍其在asd ...
阿里云ECS搭建harbor1.6.1仓库
机器信息 Centos 7.4 安装docker yum install docker #启动docker并设置开机自启 systemctl start docker systemctl enable ...
提高PHP性能效率的几个技巧！
如何提高效率问题,往往同样的功能,不一样的代码,出来的效率往往大不一样. ● 用单引号代替双引号来包含字符串,这样做会更快一些.因为PHP会在双引号包围的字符串中搜寻变量,单引号则不会,注意:只有ec ...
AppBoxFuture: 集成第三方Sql数据库
框架设计之初是不准备支持第三方数据库的,但最近几个朋友都提到需要将旧的基于传统Sql数据库的应用迁移到框架内,主要是考虑到一方面目前框架内置的分布式数据库尚未完善,另一方面是希望能逐步迭代旧应用替 ...
Few-shot Object Detection via Feature Reweighting (ICCV2019)
论文:https://arxiv.org/abs/1812.01866 代码:https://github.com/bingykang/Fewshot_Detection 1.研究背景深度卷积神经网 ...
Android 如何动态添加 View 并显示在指定位置。
引子最近,在做产品的需求的时候,遇到 PM 要求在某个按钮上添加一个新手引导动画,引导用户去点击.作为 RD,我哗啦啦的就写好相关逻辑了.自测完成后,提测,PM Review 效果. 看完后,PM ...

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

第一题：二维数组的查找

题目描述

题解：

参考代码:

第二题：替换空格

题目描述

题解：

参考代码：

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

题目描述

题解：

参考代码：

第四题：重建二叉树

题目描述

题解：

参考代码：

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

题目描述

题解：

参考代码：

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

题目描述

题解：

参考代码：

第七题：斐波那契数列

题目描述

题解：

参考代码：

第八题：跳台阶

题目描述

题解：

参考代码：

第九题：变态跳台阶

题目描述

题解：

参考代码：

第十题：矩形覆盖

题目描述

题解：

参考代码：

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

题目描述

题解：

参考代码：

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

题目描述

题解：

参考代码：

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

题目描述

题解：

参考代码：

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

题目描述

题解：

参考代码：

第十五题：反转链表

题目描述

题解：

参考代码：

第十六题 反转链表

题目描述

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

题目描述

第十八题 树的子结构

题目描述

第十九题 二叉树镜像

题目描述

输入描述:

第二十题 顺时针打印矩阵

题目描述

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

题目描述

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

题目描述

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

题目描述

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

题目描述

第十六题反转链表

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

第十八题树的子结构

第十九题二叉树镜像

第二十题顺时针打印矩阵

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

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

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

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