java经典算法以及字符串面试题

字符

字符是一个数！ 数值是Unicode编码值：

public class Demo01 {

	public static void main(String[] args) {
		char c = 0x76ae;

		System.out.println(c);
		c = 0x04c1;

		System.out.println(c); 
	}

}

经典面试题目：

统计一个英文大写字符串每个英文字符出现的次数？

答案：

public class Demo02 {

 	public static void main(String[] args) {
		/*
		 * 字符是一个数！
		 * 统计一个英文大写字符串每个英文字符出现的次数？
		 * 变形题目：
		 * 统计一个数字字符串每个数字字符出现的次数？
		 */
		String str="ABCADFOIAWEUIHJKAKJKJASKSDDDKAKAKQLMKNMV";
		int[] arr = new int[26];
		for(int i=0; i<str.length(); i++) {
			char c = str.charAt(i);
			arr[c-'A']++;
		}
		char c = 'A';
		for(int i:arr) {
			System.out.println(c++ +","+i); 
		}
	}

}

经典算法

打乱一个数组（洗牌算法）

public static void main(String[] args) {
	/*
	 * 洗牌算法
	 */
	Random random = new Random();
	int[] arr = {3,12,4,45,7,8,9};
	for(int i=arr.length-1; i>0; i--) {
		int j = random.nextInt(i);
		int t = arr[i];
		arr[i]= arr[j]; 
		arr[j]= t;
	}
	System.out.println(Arrays.toString(arr));
}

解析7进制

将一个7进制数 "123" 解析为int（不要使用API）

public class Demo04 {

	public static void main(String[] args) {
		/*
		 * 解析7进制为int
		 */
		String str = "123";
		int i = Integer.parseInt(str, 7);
		System.out.println(i); 
		i = parseInt(str, 7);
		System.out.println(i); 
		i = parseInt("127", 7);
	}
	
	public static int parseInt(String str, int base) {
		int sum = 0;
		int weight = 1;
		for(int i=str.length()-1; i>=0; i--) {
			int n = str.charAt(i) - '0';
			if(n<0 || n>=base) {
				throw new NumberFormatException(str);
			}
			sum+=n*weight;
			weight*=base;
		}
		return sum;
	}
}

案例

有0~999数字，随意去除两个数字，并且打乱顺序，请找出这个两个数字。

public class Demo05 {

	public static void main(String[] args) {
		//创建原始数组 0~999
		int[] arr = new int[1000];
		for(int i=0; i<arr.length; i++) {
			arr[i]=i;
		}
		//打乱 
		Random random = new Random();
		for(int i=arr.length-1; i>0; i--) {
			int j=random.nextInt(i);
			int t = arr[i];
			arr[i] = arr[j];
			arr[j] = t;
		}
		System.out.println(arr[arr.length-1]);
		System.out.println(arr[arr.length-2]);
		//复制减少2个
		arr = Arrays.copyOf(arr, arr.length-2);
			
		//找到这两个不存在的数
		boolean[] exist = new boolean[1000];
		for(int i:arr) {
			exist[i]=true;
		}
		//显示结果
		for(int i=0; i<exist.length; i++) {
			if(! exist[i]) {
				System.out.println(i); 
			}
		}
	}

}

二分查找

有序数据

                     21
      6
ary = 8, 10, 17, 20, 25, 40, 48, 59
      0  1   2   3   4   5   6   7

i = binarySearch(ary, 17) -> 2
i = binarySearch(ary, 21) -> -4-1  -5
i = binarySearch(ary, 6)  -> -0-1  -1

案例：

public class Demo06 {

	public static void main(String[] args) {
		/*
		 * 二分查找 API
		 */
		int[] ary = 
			{8, 10, 17, 20, 25, 40, 48, 59};
		   //0  1   2   3   4
		int i = Arrays.binarySearch(ary, 25);
		System.out.println(i); //4
		i = Arrays.binarySearch(ary, 21);
		System.out.println(i); //-5
		i = Arrays.binarySearch(ary, 6);
		System.out.println(i); //-1
	}

}

二分查找的应用

在非常大量的数据中找出前100名

原理：

public class Demo07 {

	public static void main(String[] args) {
		/*
		 * 得到100数据中前5个数据
		 */
		Random random = new Random();
		int[] top5 = new int[5];
		for(int n=0; n<100; n++) {
			int key = random.nextInt(1000);
			int index = Arrays.binarySearch(
					top5, key);
			if(index==-1||index==0) {continue;}
			if(index<0) {
				index = -(index+1);
			}
			for(int j=1; j<index; j++) {
				top5[j-1]=top5[j];
			}
			top5[index-1]=key;
			System.out.println(Arrays.toString(top5)); 
		}
		System.out.println(Arrays.toString(top5)); 
		
	}

}

案例：

public class Demo08 {

	public static void main(String[] args) {
		/*
		 * 得到100万数据中前100个数据
		 */
		Random random = new Random();
		int[] top100 = new int[100];
		for(int n=0; n<1000000; n++) {
			int key = random.nextInt(100000);
			int index = Arrays.binarySearch(
					top100, key);
			if(index==-1||index==0) {continue;}
			if(index<0) {
				index = -(index+1);
			}
			for(int j=1; j<index; j++) {
				top100[j-1]=top100[j];
			}
			top100[index-1]=key;
		}
		System.out.println(Arrays.toString(top100)); 
		
	}

}

String 与 StringBuilder

String 是不可变对象

String str = new String("ABC"); 
如上代码运行期间创建了几个对象？
答：创建了两个字符串对象

public static void main(String[] args) {
	/*
	 * 字符串字面量
	 */
	String str2 = "ABC";
	String str = new String("ABC");
	
	str = str.intern();
	//str.intern() 检查当前常量池中是否包含
	//与str一样内容的字符串，如果找到就返回
	//常量池中的引用。如果找不到就将当前字符串
	//的引用添加到常量池中。
	char[] chs = {'D','E'};
	String s3 = new String(chs);
	s3 = s3.intern();
	String s4 = "DE";
	
	System.out.println(str2);
}

int转换为n进制

public class Demo10 {

	public static void main(String[] args) {
		/*
		 * 将int转换为n进制
		 */
		int n = 66; 
		String str = toString(n, 7);
		System.out.println(str); 
		String s = Integer.toString(n, 7);
		System.out.println(s); 
	}
	public static String toString(int n, int base) {
		char[] digi="0123456789abcdefghijklmnopqrstuvwxyz"
				.toCharArray();
		char[] chs = new char[32];
		int index = chs.length-1;
		do {
			int last = n%base;
			chs[index--]=digi[last];
			n /= base;
		}while(n!=0);
		return new String(chs, index+1, 31-index);
	}

}

参数传递规则

Java 中只有一种参数传递规则： 按照值传递，简称值传递！

值传递的本质就是将变量的值复制一份到方法参数。

public class Demo11 {
	public static void main(String[] args) {
		String s = "A";
		StringBuilder ss=new StringBuilder("A");
		test(s, ss);
		System.out.println(s); //A
		System.out.println(ss);//AA
		
		int a = 5;
		int[] ary= {5};
		test(a, ary);
		System.out.println(a);
		System.out.println(ary[0]);
	}
	public static void test(int a, int[] arr) {
		a++;
		arr[0]++;
	}
	
	public static void test(
			String s, StringBuilder ss) {
		s+="A";
		ss.append("A");
	}
}