牛客网-剑指offer

1、重建二叉树

import java.util.Arrays;

/**
 * 
 * @author 崔洪振367
 * @version 创建时间：2017年6月28日 下午8:21:21
 */
public class 重建二叉树 {

	public TreeNode reConstructBinaryTree(int[] pre, int[] in)  {

		if(pre == null || pre.length == 0 || in == null || in.length == 0){
			return null;
		}
		
		if(pre.length != in.length){
			//throw new Exception("两个数组的大小不一致");
			return null;
		}
		
		TreeNode treeNode = null;
		for(int i=0; i<in.length; i++){
			if(pre[0] == in[i]){
				treeNode = new TreeNode(in[i]);
				System.out.println(treeNode.val);
				treeNode.left = reConstructBinaryTree(Arrays.copyOfRange(pre, 1, i+1), 
						Arrays.copyOfRange(in, 0, i));
				treeNode.right = reConstructBinaryTree(Arrays.copyOfRange(pre, i+1, pre.length),
						Arrays.copyOfRange(in, i+1, in.length));
			}
		}
		
		return treeNode;
	}

}

// Definition for binary tree
class TreeNode {
	int val;
	TreeNode left;
	TreeNode right;

	TreeNode(int x) {
		val = x;
	}
}

此题使用递归来实现的，个人感觉关键还是理解过程。同时要注意Java集合中的一些常用的函数，此处比如：Arrays.copyOfRange(int[] nums, int from, int to)函数的用法。

2、用两个栈实现队列

import java.util.Stack;

/** 
 * 解题思路：如果是入队，就是将元素添加到stack1中，但是出队前要判断stack2是否为空&&stack1不为空才出队，否则输出-1.
 * @author 崔洪振367
 * @version 创建时间：2017年6月28日 下午8:50:30 
 */
public class 用两个栈实现队列 {
	
	Stack<Integer> stack1 = new Stack<Integer>();
	Stack<Integer> stack2 = new Stack<Integer>();
	
    //实现队列的出队操作
    public void push(int node) {
        stack1.push(node);
    }
    
    //实现队列的入队操作
    public int pop() {
    
    	//只有栈2为空的时候才可以出队，否则，就会打乱出队的顺序
    	if(stack2.isEmpty()){
    		while(!stack1.isEmpty()){
    			stack2.push(stack1.pop());
    		}
    	}
    	if(stack2.isEmpty()){//此处栈2为空，输出-1
    		return -1;
    	}
    	return stack2.pop();
    }

}

3、旋转数组的最小值

/** 
 * 
 * @author 崔洪振367
 * @version 创建时间：2017年6月28日 下午9:02:07 
 */

import java.util.ArrayList;
public class 旋转数组的最小数字 {
	public int minNumberInRotateArray(int [] array) {
	    if(array == null || array.length == 0){
	    	return 0;
	    }
	 
	    int min = array[0];
	    if(array.length == 1){
	    	return min;
	    }
	    
	    for(int i=1; i<array.length - 1; i++){
	    	if(min > array[i]){
	    		min = array[i];
	    		break;
	    	}
	    }
		return min;
    }

}

4、数值的整数次方

import org.junit.Test;

/**
 * 
 * @author 崔洪振367
 * @version 创建时间：2017年6月29日 下午4:36:09
 */
public class 数值的整数次方 {
	@Test
	public void getPower(){
		Power(2.0, 2);
	}
	
	public double Power(double base, int exponent) {
		double pow = 1.0d;
		boolean flag = true;
		if(exponent < 0){
			flag = false;
			exponent = -exponent;
		}
		while(exponent > 0){
			pow *= base;
			exponent--;
		}
		if(flag == false){
			return 1.0/pow;
		}
		return pow;
	}

}

5、二进制中1的个数

/**
 * 
 * @author 崔洪振367
 * @version 创建时间：2017年6月29日 下午4:15:46
 */
public class 二进制中1的个数 {

	public int NumberOf1(int n) {
		if(n == 0){
			return 0;
		}
		
		//根据不断右移二进制数字，并且判断右移后的最右端数字和1的与运算结果，如果为1则统计1的个数的变量count+1.
		int count = 0;
		while(n !=0 ){
			if((n&1) == 1){
				count++;
			}
			n = n >> 1;
		}
		
		return count;
	}
	
	public int NumberOf1_(int n){
		int count = 0;
		while(n!=0){
			count++;
			n = (n-1)&n;
		}
		
		return count;
	}
}

说明：方法一可以在本地IDE中编译通过并计算。但是不能再牛客网的测试用例中通过。

方法二：即NumOf1_(int n)能够通过牛客网的所有测试用例。相比较而言，还是方法二比较靠谱，方法一不排除存在死循环的情况。感兴趣的可以找出几个测试的例子分享一下。