1. 重建二叉树
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回
递归构建二叉树
1. 分析
根据中序遍历和前序遍历可以确定二叉树，具体过程为：
- 根据前序序列第一个结点确定根结点
- 根据根结点在中序序列中的位置分割出左右两个子序列
- 对左子树和右子树分别递归使用同样的方法继续分解
例如：
前序序列{1,2,4,7,3,5,6,8} = pre
中序序列{4,7,2,1,5,3,8,6} = in
- 根据当前前序序列的第一个结点确定根结点，为 1
- 找到 1 在中序遍历序列中的位置，为 in[3]
- 切割左右子树，则 in[3] 前面的为左子树， in[3] 后面的为右子树
- 则切割后的左子树前序序列为：{2,4,7}，切割后的左子树中序序列为：{4,7,2}；切割后的右子树前序序列为：{3,5,6,8}，切割后的右子树中序序列为：{5,3,8,6}
- 对子树分别使用同样的方法分解
2. 代码
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
import java.util.Arrays;
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
if (pre.length == 0 || in.length == 0) {
return null;
}
TreeNode root = new TreeNode(pre[0]);
// 在中序中找到前序的根
for (int i = 0; i < in.length; i++) {
if (in[i] == pre[0]) {
// 左子树，注意 copyOfRange 函数，左闭右开
root.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i + 1), Arrays.copyOfRange(in, 0, i));
// 右子树，注意 copyOfRange 函数，左闭右开
root.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i + 1, pre.length), Arrays.copyOfRange(in, i + 1, in.length));
break;
}
}
return root;
}
}
2. 从头到尾打印链表
输入一个链表，按链表从尾到头的顺序返回一个ArrayList
思路
遍历链表，用集合存起来，Collections.reverse(list)进行反转
代码
/**
* public class ListNode {
* int val;
* ListNode next = null;
*
* ListNode(int val) {
* this.val = val;
* }
* }
*
*/
import java.util.*;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
List<Integer> list = new ArrayList<Integer>();
while(listNode!=null){
list.add(listNode.val);
listNode = listNode.next;
}
Collections.reverse(list);
return (ArrayList<Integer>)list;
}
}
3. 用两个栈实现队列
1. 分析
队列的特性是：“先入先出”，栈的特性是：“先入后出”
当我们向模拟的队列插入数 a,b,c 时，假设插入的是 stack1，此时的栈情况为：
- 栈 stack1：{a,b,c}
- 栈 stack2：{}
当需要弹出一个数，根据队列的"先进先出"原则，a 先进入，则 a 应该先弹出。但是此时 a 在 stack1 的最下面，将 stack1 中全部元素逐个弹出压入 stack2，现在可以正确的从 stack2 中弹出 a，此时的栈情况为：
- 栈 stack1：{}
- 栈 stack2：{c,b}
继续弹出一个数，b 比 c 先进入，b 弹出，注意此时 b 在 stack2 的栈顶，可直接弹出，此时的栈情况为：
- 栈 stack1：{}
- 栈 stack2：{c}
此时向模拟队列插入一个数 d，还是插入 stack1，此时的栈情况为：
- 栈 stack1：{d}
- 栈 stack2：{c}
弹出一个数，c 比 d 先进入，c 弹出，注意此时 c 在 stack2 的栈顶，可直接弹出，此时的栈情况为：
- 栈 stack1：{d}
- 栈 stack2：{c}
根据上述栗子可得出结论：
- 当插入时，直接插入 stack1
- 当弹出时，当 stack2 不为空，弹出 stack2 栈顶元素，如果 stack2 为空，将 stack1 中的全部数逐个出栈入栈 stack2，再弹出 stack2 栈顶元素
2. 代码
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.size()<=0){//用来取数据的stack2栈没有数据时
while(stack1.size()!=0){//遍历stack1栈往stack2栈中加入数据
stack2.push(stack1.pop());
}
}
return stack2.pop();
}
}
4. 旋转数组的最小数字
题目描述
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。
1. 分析
在两段范围内都是非降序，当不符合这个规律时，就找到了最小数字
2. 代码
import java.util.ArrayList;
public class Solution {
public int minNumberInRotateArray(int [] array) {
int n = array.length;
if(n==0){
return 0;
}
for (int i = 0; i < n; i++) {
if(array[i]>array[i+1]){
return array[i+1];
}
}
return array[0];
}
}
5. 斐波那契数列
题目描述
大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。n<=39
1. 分析
斐波那契数列的标准公式为：F(1)=1，F(2)=1, F(n)=F(n-1)+F(n-2)（n>=3，n∈N*）
根据公式可以直接写出：
2. 代码
public class Solution {
public int Fibonacci(int n) {
if(n<=1){
return n;
}
return Fibonacci(n-1)+Fibonacci(n-2);
}
}
6. 跳台阶
题目描述
一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
1. 思路
跳n级台阶相当于n-1和n-2级台阶的和
2. 代码
public class Solution {
public int JumpFloor(int target) {
if(target<=0){
throw new RuntimeException();
}
if(target==1||target==2){
return target;
}
return JumpFloor(target-1)+JumpFloor(target-2);
}
}
原文链接：
来源：牛客网
