源码记录

(1)类似正则表达式匹配问题， 例如s1 = "xxxxabxxxxbxx", s2 = "ab*b??"

public class Regex {
	static boolean scan(String s1, String s2){
		for(int i=0; i<s1.length(); i++){
			int cur = i, j;
			for(j=0; j<s2.length()&&cur<s1.length(); j++){
				if(s1.charAt(cur)==s2.charAt(j)){
					cur++;
				}else if(s2.charAt(j)=='?'){
					cur++;
				}else if(s2.charAt(j)=='*'){
					String tmps1 = s1.substring(cur), 
							tmps2 = s2.substring(++j);
					boolean b = scan(tmps1, tmps2);
					if(b) return b;
					else break;
				}else if(s1.charAt(cur)!=s2.charAt(j)){
					break;
				}
			}
			if(j==s2.length()) return true;
		}
		return false;
	}
	
	public static void main(String [] args){
		String s1 = "xxaxxbxabcb";
		String s2 = "ab*b??";
		System.out.println(scan(s1, s2));
	}

}

(2)求数组集合子集递归和非递归求法。

public class FindAllSubSet {
	public static void findAllSubSet(int [] a){
		int n = a.length;
		for(int i=0; i<Math.pow(2, n); i++){
			int cur = i;
			for(int j=0; j<n; j++){
				if((cur&1)==1){
					System.out.print(a[j]+" ");
				}
				cur >>= 1;
			}
			System.out.println();
		}
	}
	static void findSubSet(int [] a, boolean [] aux, int cur){
//		System.out.println(cur);
		if(cur>=a.length){
			for(int i=0; i<aux.length; i++){
				if(aux[i])
					System.out.print(a[i]+" ");
			}
			System.out.println();
			return;
		}
		int tmp = cur;
		findSubSet(a, aux, ++tmp);
		aux[cur] = true;
		findSubSet(a, aux, tmp);
		aux[cur] = false;
	}
	public static void main(String [] args){
		int [] a = {1, 2, 3};
//		findAllSubSet(a);
		boolean [] aux = new boolean[a.length];
		findSubSet(a, aux, 0);
	}

}

（3）按照老鼠体重升序排序， 然后按速度找最大降序子序列

import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.Stack;


public class SortMices {
	static class Mice{
		int weight, speed;
		public Mice(int w, int s){
			this.weight = w;
			this.speed = s;
		}
		public String toString(){
			return "weight = "+this.weight+"  speed="+this.speed;
		}
	}
	static void findMiceSet(Mice[] ms){
		Arrays.sort(ms, new Comparator<Mice>(){
			public int compare(Mice m1, Mice m2){
				if(m1.weight>m2.weight) return 1;
				else if(m1.weight<m2.weight) return -1;
				else return 0;
			}
		});
		show(ms);
		List<Mice> list = new LinkedList<Mice>();
		for(int i=0; i<ms.length; i++){
			int j;
			for(j=0; j<list.size(); j++){
				if(ms[i].speed>list.get(j).speed) break;
			}
			if(j==list.size()) list.add(ms[i]);
			else list.set(j, ms[i]);
		}
		System.out.println(list.size());
		int pre = Integer.MIN_VALUE;
		int j = ms.length-1;
		Stack<Mice> results = new Stack<Mice>();
		for(int i=list.size()-1; i>=0; i--){
			while(j>=0){
				if(ms[j].speed>pre&&ms[j].speed<=list.get(i).speed){
					results.push(ms[j]);
					pre = ms[j].speed;
					j--;
					break;
				}
				j--;
			}
		}
		while(!results.empty()){
			Mice m = results.pop();
			System.out.println(m.weight+" , "+m.speed);
		}
	}
	static void show(Mice [] ms){
		for(int i=0; i<ms.length; i++)
			System.out.println(ms[i]);
	}
	public static void main(String [] args){
		Mice [] ms = {new Mice(2, 5), new Mice(9, 1), new Mice(8, 2), new Mice(5, 4), new Mice(3, 3)};
		show(ms);
		System.out.println("+++++++++++++++++++++++++++++");
		findMiceSet(ms);
	}

}

（4）合法的鸡蛋方法

/**
 * N个鸡蛋放入M个篮子中， 篮子不能为空， 要满足， 对任意不大于N的数量， 能用若干个篮子中的鸡蛋的和表示
 * 方法是用枚举所有可能的排列方法。
 * @author Administrator
 *
 */
public class PutEggs {
	/**
	 * 确认篮子可以组合出所有不大于N的数量
	 * @param n
	 * @param bs
	 * @return
	 */
	static boolean confirm(int n, int[] bs){
		boolean [] ns = new boolean[n+1];
		int ss = bs.length;
		for(int i=0; i<Math.pow(2, ss); i++){
			int cur = i;
			int sum = 0;
			for(int j=0; j<ss;j++){
				if((cur&1)==1){
					sum += bs[j];
				}
				cur >>=1;
			}
			ns[sum] = true;
		}
		for(int i=1; i<ns.length; i++){
			if(!ns[i]) return false;
		}
		return true;
	}
	static void show(boolean [] bs){
		for(int i=0; i<bs.length; i++){
			System.out.print(bs[i]+" ");
		}
		System.out.println();
	}
	static void show(int [] bs){
		for(int i=0; i<bs.length; i++){
			System.out.print(bs[i]+" ");
		}
		System.out.println();
	}
	/**
	 * 回溯遍历
	 * @param N
	 * @param eggs
	 * @param buckets
	 * @param cur
	 */
	static void putEggs(int N, int eggs, int [] buckets, int cur){
		if(eggs==0){
			if(cur==buckets.length&&confirm(N, buckets)){
				show(buckets);
			}
			return;
		}else if(cur==buckets.length){
			return;
		}
		
		int tmp = cur + 1;
		for(int i=eggs; i>0; i--){
			buckets[cur] = i;
			putEggs(N, eggs-i, buckets, tmp);
		}
		buckets[cur] = 0;
	}
	
	public static void main(String [] args){
		int [] bs = new int[5];
		putEggs(9, 9, bs, 0);
	}

}

（5）统计字符数

import java.util.HashMap;

/**
 * 时间复杂度O(N)时间内， 统计String中字符出现的次数
 * @author Administrator
 *
 */
public class CountChars {
	static HashMap<Character, Integer> count(String s ){
		int [] cc = new int [256];
		for(char a : s.toCharArray()){
			cc[a] ++;
		}
		HashMap<Character, Integer> counts = new HashMap<Character, Integer>();
		for(int i=0; i<cc.length; i++){
			if(cc[i]>0){
				counts.put((char)i, cc[i]);
			}
		}
		return counts;
	}
	
	public static void main(String [] args){
		String s = "AAbbaacccces";
		HashMap<Character, Integer> c = count(s);
		for(char a: c.keySet()){
			System.out.println(a+"  : "+c.get(a));
		}
	}

}

（6）输入：一个长度为n的整数数组input 
输出：一个长度为n的整数数组result，满足result[i] = input数组中除了input[i]之外所有数的乘积（假设不会溢出）。比如输入：input = {2,3,4,5}，输出result = {60,40,30,24} 

public class CalculateProduct {
	
	public static int [] cal(int [] a){
		int [] re = new int[a.length];
		int pr = 1;
		for(int i=0; i<a.length; i++){
			re[i] = pr;
			pr *= a[i];
		}
		pr = a[a.length-1];
		for(int i = a.length-2; i>=0; i--){
			re[i] *= pr;
			pr *= a[i];
		}
		return re;
	}
	public static void show(int [] a){
		for(int i=0; i<a.length; i++){
			System.out.println(a[i]);
		}
	}
	public static void main(String [] args){
		int [] a = {1, 2, 3, 4, 5};
		a = cal(a);
		show(a);
	}

}

（7）有n个人排队， 每个人都有要求Request， 具体每个要求是希望排在某个人之前或者之后， 用类RequestItem表示。

例如有 1， 2， 3三个人， 1希望排在2之后3之前， 2希望排在1之前， 3希望排在1， 2之后。输出一个合理的排列

一个拓扑排序的应用

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;


class RequestItem{
	String name;
	boolean front;
}

class Request{
	String name;
	List<RequestItem> items;
}
public class FindValidOrder {
	static List<String> validOrder(List<String> names, List<Request> requests){
		HashMap<String, List<String>> maps = new HashMap<String, List<String>>();
		for(String name: names){
			maps.put(name, new LinkedList<String>());
		}
		for(Request re: requests){
			for(RequestItem item: re.items){
				if(item.front){
					List<String> tmp = maps.get(item.name);
					if(!tmp.contains(re.name)){
						tmp.add(re.name);
					}
				}else{
					List<String> tmp = maps.get(re.name);
					if(!tmp.contains(item.name)){
						tmp.add(item.name);
					}
				}
				
			}
		}
		HashMap<String, Integer> counts = new HashMap<String, Integer>();
		for(String name: names){
			counts.put(name, 0);
		}
		for(String name: names){
			List<String> tmp = maps.get(name);
			for(String s: tmp){
				int tmpcount = counts.get(s)+1;
				counts.put(s, tmpcount);
			}
		}
		List<String> queue = new LinkedList<String>();
		while(!counts.isEmpty()){
			boolean found = false;
			String next = null;
			for(String name: counts.keySet()){
				if(counts.get(name)==0){
					next = name;
					found = true;
				}
			}
			if(!found) break;
			counts.remove(next);
			for(String s: maps.get(next)){
				int tmpcount = counts.get(s)-1;
				counts.put(s, tmpcount);
			}
			queue.add(next);
		}
		if(queue.size() == names.size()) return queue;
		return null;
	}
	public static void main(String [] args){
		List<String> names = new LinkedList<String>();
		names.add("1");
		names.add("2");
		names.add("3");
		List<Request> requests = new LinkedList<Request>();
		
		Request r = new Request();
		r.name = "1";
		r.items = new LinkedList<RequestItem>();
		RequestItem item = new RequestItem();
		item.name = "2";
		item.front = true;
		r.items.add(item);
		RequestItem item2 = new RequestItem();
		item2.name = "3";
		item2.front = false;
		r.items.add(item2);
		requests.add(r);
		
		Request r2 = new Request();
		r2.name = "2";
		r2.items = new LinkedList<RequestItem>();
		RequestItem item3 = new RequestItem();
		item3.name = "1";
		item3.front = false;
		r2.items.add(item3);
		requests.add(r);
		
		Request r3 = new Request();
		r3.name = "3";
		r3.items = new LinkedList<RequestItem>();
		RequestItem item4 = new RequestItem();
		item4.name = "2";
		item4.front = true;
		r3.items.add(item4);
		RequestItem item5 = new RequestItem();
		item5.name = "1";
		item5.front = true;
		r3.items.add(item5);
		requests.add(r3);
		
		List<String> order = validOrder(names, requests);
		System.out.println(order);
	}

}