Android 面试题之编程

1、排序

package cn.java.suanfa;

public class SuanFa {

	public static void main(String[] args) {

		int[] arr = {5,7,3,9,1,3,2};
//		selectSort(arr);
		System.out.println(" ------------------- ");
//		maopaoSort(arr);
		quickSort(arr,0,arr.length-1);

	}
	/**
	 * Java排序算法（六）：直接插入排序
	 *  直接插入排序的基本操作就是将待排序的数据元素按其关键字值的大小插入到前面的有序序列中。
	 *  直接插入的时间效率并不高，如果在最坏的情况下，所有元素的比较次数总和为（0+1+...+n-1）=O(n^2)
	 *  。其他情况下也要考虑移动元素的次数，故时间复杂度为O(n^2)  直接插入空间效率很好，
	 *  只需要1个缓存数据单元，也 就是说空间复杂度为O(1). 直接插入排序是稳定的。  直接插入排序在数
	 *  据已有一定顺序的情况下，效率较好。但如果数据无规则，则需要移动大量的数据，其效率就与冒泡排序
	 *  法和选择排序法一样差了。
	 *  算法描述
	 *     对一个有n个元素的数据序列，排序需要进行n-1趟插入操作：
	 *     第1趟插入，将第2个元素插入前面的有序子序列--此时前面只有一个元素，当然是有序的。
	 *     第2趟插入，将第3个元素插入前面的有序子序列，前面2个元素是有序的。
	 *     第n-1趟插入，将第n个元素插入前面的有序子序列，前面n-1个元素是有序的。
	 * @param data
	 */
	public static void insertSort(int[] data) {
		for (int i = 1; i < data.length; i++) {
			// 缓存i处的元素值
			int tmp = data[i];
			if (data[i] < data[i - 1]) {
				int j = i - 1;
				// 整体后移一格
				while (j >= 0 && data[j] > tmp) {
					data[j + 1] = data[j];
					j--;
				}
				// 最后将tmp插入合适的位置
				data[j + 1] = tmp;
				print(data);
			}
		}
	}

	/**
	 * Java排序算法（五）：快速排序
	 * 快速排序是一个速度非常快的交换排序算法，它的基本思路很简单，从待排的数据序列中任取一个数据（如第一
	 * 个数据）作为分界值，所有比它小的数据元素放到左边，所有比它大的数据元素放到它的右边。经过这样一趟下
	 * 来，该序列形成左右两个子序列，左边序列中的数据元素的值都比分界值小，右边序列中数据元素的值都比分界
	 * 值大。  接下来对左右两个子序列进行递归排序，对两个子序列重新选择中心元素并依此规则调整，直到每个元素
	 * 子表的元素只剩下一个元素，排序完成。 思路：
	 * 1.定义一个i变量，i变量从左边第一个索引开始，找大于分界值的元素的索引，并用i来记录它。
	 * 2.定义一个j变量，j变量从右边第一个索引开始，找小于分界值的元素的索引，并用j来记录它。
	 * 3.如果i<j，交换i,j两个索引处的元素。  重复执行以上1,2,3步，直到i>=j，可以判断j左边的数据元
	 * 素都小于分界值，j右边的数据元素都大于分界值，最后将分界值和j索引处的元素交换即可。 时间复杂度 
		最好情况（每次总是选到中间值作枢轴）T(n)=O(nlogn) 
		最坏情况（每次总是选到最小或最大元素作枢轴） 做n-1趟，每趟比较n-i次，
		总的比较次数最大：[O(n²)] 
		平均时间复杂度为：：T(n)=O(nlogn) 
	 * @param data
	 * @param start
	 * @param end
	 */
	public static void quickSort(int[] data, int start, int end) {
		if (start >= end) {
			return;
		}
		int middleVal = data[start];
		int i = start + 1;
		int j = end;

		while (true) {
			while (i <= end && data[i] < middleVal) {
				i++;
			}
			while (j > start && data[j] > middleVal) {
				j--;
			}
			if (i<j) {
				swap(data,i,j);
			}else {
				break;
			}
		}

		//交换j 与 start的值
		swap(data, start, j);
		//递归左边
		quickSort(data,start,j-1);
		//递归右边
		quickSort(data,j+1,end);
	}

	/**
	 * 冒泡排序
	 * 冒泡排序是计算机的一种排序方法，它的时间复杂度为O（n^2），虽然不及堆排序、快速排序的O（nlogn，底数
	 * 为2），但是有两个优点：  1.“编程复杂度”很低，很容易写出代码；  2.具有稳定性，这里的稳定性是指原序列中
	 * 相同元素的相对顺序仍然保持到排序后的序列，而堆排序、快速排序均不具有稳定性。
	 * 不过，一路、二路归并排序、不平衡二叉树排序的速度均比冒泡排序快，且具有稳定性，但速度不及堆排序、
	 * 快速排序。冒泡排序是经过n-1趟子排序完成的，
	 * 第i趟子排序从第1个数至第n-i个数，若第i个数比后一个数大（则升序，小则降序）则交换两数。
	 * 冒泡排序算法稳定，O(1)的额外的空间，比较和交换的时间复杂度都是O(n^2)，自适应，对于已基本排序的算法，
	 * 时间复杂度为O(n)。冒泡算法的许多性质和插入算法相似，但对于系统开销高一点点。
	 * @param arr
	 */
	public static void maopaoSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			 for (int j = i+1; j < arr.length; j++) {
				if (arr[i]>arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
					print(arr);
				}
			}
		}
	}

	/**
	 * 选择排序
	 * 直接选择排序的基本操作就是每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的
	 * 数列的最后，直到全部待排序的数据元素排完，它需要经过n-1趟比较。算法不稳定，O(1)的额外的空间，比较
	 * 的时间复杂度为O(n^2)，交换的时间复杂度为O(n)，并不是自适应的。在大多数情况下都不推荐使用。只有在
	 * 希望减少交换次数的情况下可以用。
	 * @param arr
	 */
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[minIndex] > arr[j]) {
					minIndex = j;
				}
			}
			if (minIndex != i) {
				int temp = arr[i];
				arr[i] = arr[minIndex];
				arr[minIndex] = temp;
				print(arr);
			}
		}
	}

	public static void print(int[] data) {
		for (int i = 0; i < data.length; i++) {
			System.out.print(data[i] + "\t");
		}
		System.out.println();
	}

	private static void swap(int[] data, int i, int j){
		int temp = data[i];
		data[i] = data[j];
		data[j] = temp;
		print(data);
	}
}

/**
 * 创建二叉树，对数组进行排序
 * @author libin
 *
 */
public class BinaryTree {

	public int value;
	public BinaryTree left;
	public BinaryTree right;

	public BinaryTree(int value){
		this.value = value;
	}

	public void addValue(int val){
		if(val<value){
			if (left==null) {
				left = new BinaryTree(val);
			}else {
				left.addValue(val);
			}
		}else if(val>value){
			if (right==null) {
				right = new BinaryTree(val);
			}else {
				right.addValue(val);
			}
		}
	}

	public boolean find(int val){
		if(this.value == val){
			return true;
		}
		if(val>this.value){
			if(right==null){
				return false;
			}else {
				return right.find(val);
			}
		}
		if(val<this.value){
			if(left==null){
				return false;
			}else {
				return left.find(val);
			}
		}
		return false;
	}

	public void display() {
		if (left != null) {
			left.display();
		}
		System.out.println(value);
		if (right != null) {
			right.display();
		}
	}

	public static void main(String[] args) {
		int[] arrs = new int[10];
		for (int i = 0; i <10; i++) {
			Random random = new Random();
			int num = random.nextInt(200);
			while(contains(arrs, num)) {
				num = random.nextInt(200);
			}
			arrs[i]=num;
		}

		System.out.println(Arrays.toString(arrs));

		BinaryTree tree = new BinaryTree(arrs[0]);
		for (int i = 1; i <10; i++) {
			tree.addValue(arrs[i]);
		}
		tree.display();
	}

	public static boolean contains(int[] arr,int val){
		for (int i = 0; i < arr.length; i++) {
			if (arr[i]==val) {
				return true;
			}
		}
		return false;
	}

}

2、

public class CalByteNum {

	public static void main(String[] args) throws Exception {
		//对应字节 105  -25  -120  -79  121  111  117  50
		String str = "i爱you2";
		int by = calByte(str.getBytes("GBK"),3);
		System.out.println(str.substring(0, by));
	}
	/**
	 * 截取字符串，当遇到半个汉字时将会舍弃。
	 * calByte(str.getBytes("GBK"),2) ---> 输出：i
	 * calByte(str.getBytes("GBK"),3) ---> 输出：i爱
	 * @param buf
	 * @param cut
	 * @return
	 */
	public static int calByte(byte[] buf,int cut){
		int resNum=0;
		int chineseFlag = 0;
		for (int i = 0; i < cut; i++) {
			if (buf[i]<0 ) {
				if(chineseFlag==1){
					chineseFlag=0;
					resNum++;
				}else{
					chineseFlag++;
				}
			}else {
				resNum++;
			}
		}
		return resNum;
	}
}