算法题解答

 

2.设计包含min函数的栈。

定义栈的数据结构，要求添加一个min函数，能够得到栈的最小元素。

要求函数min、push以及pop的时间复杂度都是O(1)。

思想:构建辅助的栈，依次记录下，原来栈中最小的值的索引需

 

/**
 * 在栈中找到最小函数min() 保证每一次进栈push() 出栈pop()能取得最小值
 * @author Administrator
 */
public class algorithm3{
	/**
	 * 作为使用栈
	 * @author Administrator
	 */
	static class Stack{
		List<Integer> array=new ArrayList();
		NeedStack needStack=new NeedStack();
	    //记录栈中的最小值
		int min=65535;
		//从后面进
		public void push(int a){
			//先进栈
			array.add(a);
			//如果进栈的时候 
			if(a<min){
				needStack.push(a);
				min=a;
			}
		}		
		//从后面出栈
		public int pop(){
		  int need=array.get(array.size()-1);
		  array.remove(array.size()-1);
		  //从辅助数组中取出最小的
		  int min=needStack.pop();
		  //如果不是最小的在放回去
		  if(need!=min){
			  needStack.push(min);
		  }
		  return  need;
		}
		
	}
	
	/**
	 * 作为辅助栈最小值的栈
	 * @author Administrator
	 */
	static class NeedStack{
		List<Integer> array=new ArrayList();
		//从后面进
		public void push(int a){
		   array.add(a);
		}
		//从后面出栈
		public int pop(){
		   int a= array.get(array.size()-1);
		   array.remove(array.size()-1);
		   return a;
		}
	}
}

 

3.求子数组的最大和

题目：

输入一个整形数组，数组里有正数也有负数。

数组中连续的一个或多个整数组成一个子数组，每个子数组都有一个和。

求所有子数组的和的最大值。要求时间复杂度为O(n)。

 

例如输入的数组为1, -2, 3, 10, -4, 7, 2, -5，和最大的子数组为3, 10, -4, 7, 2，

因此输出为该子数组的和18。

思想:从第一个开始依次做和的累积，如果和小于0，就证明子序列不足以产生最大子序列和，再从后面一个位置开始计数。

 

public static void main(String[] args) {
		int[] a={1,-2,3,10,-4,7,2,-5};
		
		int max=0;
		int sum=0;
		for(int i=0;i<a.length;i++){
			sum=sum+a[i];
			if(sum<0){
				sum=0;
			}else if(max<sum){
				max=sum;
			}
		}
		System.out.println(max);
	}

 

4.在二元树中找出和为某一值的所有路径

 

题目：输入一个整数和一棵二元树。

从树的根结点开始往下访问一直到叶结点所经过的所有结点形成一条路径。

打印出和与输入整数相等的所有路径。

例如 输入整数22和如下二元树

思想：

1 遍历判断是否是叶子节点

2 如果是叶子节点，递归回溯找到父节点依次求和 (2i左孩子   2i+1右孩子)

3 和等于输入值

4 从当前节点递归遍历打印节点路径 (2i左孩子   2i+1右孩子) 

package xiao.it.java;

import java.util.ArrayList;

public class algorithm4 {
	/** * @param args */
	public static void main(String[] args) {
		ArrayList<Integer> list = new ArrayList();
		list.add(0);
		list.add(10);
		list.add(5);
		list.add(12);
		list.add(4);
		list.add(7);
		for (int i = 1; i < list.size(); i++) {
			Integer node = list.get(i);
			int sum = node;
			if (isTL(list, node)) {
				sum = cal(list, node, sum);
				if (sum == 22) {
					System.out.println("--------------------");
					print(list, node);
				}
			}
		}
	}

	static void print(ArrayList<Integer> list, int node) {
		System.out.println(node);
		int indexOf = list.indexOf(node);
		int parent = indexOf / 2;
		if (parent != 0) {
			print(list, list.get(parent));
		}
	}

	static int cal(ArrayList<Integer> list, int node, int sum) {
		int indexOf = list.indexOf(node);
		int parent = indexOf / 2;
		if (parent != 0) {
			sum = sum + list.get(parent);
			return cal(list, list.get(parent), sum);
		} else {
			return sum;
		}
	}

	static boolean isTL(ArrayList<Integer> list, int a) {
		int index = list.indexOf(a);
		int leftC = 2 * index;
		int rightC = 2 * index + 1;
		if (leftC > list.size() || rightC > list.size()) {
			return true;
		}
		return false;
	}
}

 

5.查找最小的k个元素

题目：输入n个整数，输出其中最小的k个。

例如输入1，2，3，4，5，6，7和8这8个数字，则最小的4个数字为1，2，3和4。

思想：解决这题 其实不需要思考太久，就是用了一个java的排序集合，然后每添加一个

数字，它就自动排序，最后打印出前四个最小的数字就可以了

public class Test {
	public static void main(String[] args) {
	   TreeSet<Integer> tree=new TreeSet<Integer>();
	   while(tree.size()<10){
		   Scanner scanner=new Scanner(System.in);
		   int nextInt = scanner.nextInt();
		   tree.add(nextInt);
	   }
	    Iterator<Integer> iterator = tree.iterator();
	    int index=0;
	    while(iterator.hasNext()){
	    	System.out.println(iterator.next());
	    	index++;
	    	if(index>3){
	    		break;
	    	}
	    }
	}
}

结果

 

 

第6题

腾讯面试题：

给你10分钟时间，根据上排给出十个数，在其下排填出对应的十个数

要求下排每个数都是先前上排那十个数在下排出现的次数。

上排的十个数如下：

【0，1，2，3，4，5，6，7，8，9】

 

举一个例子，

数值: 0,1,2,3,4,5,6,7,8,9

分配: 6,2,1,0,0,0,1,0,0,0

0在下排出现了6次，1在下排出现了2次，

2在下排出现了1次，3在下排出现了0次....

以此类推..

 

题目分析

简题思路
    b[i]*a[i]的和等于10
    b[i]的和等于10
    b[i]<10
    b[i]*a[i]<10

    a[i]在b中出现了b[i]个

 

 

public class TestAogrithm {
   public static void main(String[] args) {
	 int[] a= {0,1,2,3,4,5,6,7,8,9}; 
	 for(int i=0;i<9999999999l;i++) {
		 BFactory factory = generateFactory(i);
		 BFactory calculator = Calculator(a, factory);
		 if(calculator.isAvalibal) {
			 Object[] array = calculator.getLis().toArray();
			for(int x=0;x<array.length;x++) {
				System.out.print(array[x]);
			}
			System.out.println();
		 }
	 } 
   }

/**   
 * @Title: generateFactory   
 * @Description: TODO(生成一个b[i])   
 * @return       
 * @throws   
 */
private static BFactory generateFactory(int i) {
	BFactory factory=new BFactory();
	String str=i+"";
	if(str.length()<10) {
		for(int j=0;j<str.length();j++) {
			char charAt = str.charAt(j);
			factory.getLis().add(Integer.valueOf(charAt+""));
		}
	}		
    while(factory.getLis().size()<10) {
    	factory.getLis().add(0);
    }
	return factory;
}

/**   
 * @Title: Calculator   
 * @Description: TODO(计算如果b没问题就返回)   
 * @param a
 * @param factory       
 * @throws   
 */
private static BFactory  Calculator(int[] a, BFactory factory) {
	 int sumA=0;
	 for(int i=0;i<factory.getLis().size();i++) {
		 Integer b = factory.getLis().get(i);
	     sumA=sumA+b*a[i];
	 }
	 if(sumA!=10)return factory;
	 int sumB=0;
	 for(int i=0;i<factory.getLis().size();i++) {
		 Integer b = factory.getLis().get(i);
		 sumB=sumB+b;
	 }
	 if(sumB!=10) return factory;
	 
	 for(int i=0;i<factory.getLis().size();i++) {
			 int bi=factory.getLis().get(i);
			 int count=0;
			 for(int j=0;j<factory.getLis().size();j++) {
				 if(factory.getLis().get(j)==a[i]) {
					 count++;
				 }
			 }
			if(bi!=count) return factory;
	 }
	 
	 factory.setAvalibal(true);
	 return factory;
}
   
   static class BFactory{
	    boolean isAvalibal=false;
	    public boolean isAvalibal() {
			return isAvalibal;
		}

		public void setAvalibal(boolean isAvalibal) {
			this.isAvalibal = isAvalibal;
		}

		List<Integer> lis=new ArrayList();

	    public List<Integer> getLis() {
			return lis;
	    }
	
		public void setLis(List<Integer> lis) {
			this.lis = lis;
		}
   }
}

结果