1、第一题
题目描述
假设有一个已经排好序的整型数组，要求实现一个使用二分查找的函数，判断某个数字是否出现在该数组中。
题目分析
这道题目相对来说很简单，二分查找可用递归或者迭代实现，主要是中间值进行比较。
解决方法：
输入一个已经排好序的整型数组以及待查的数组，返回一个布尔值，表示查询的值是否存在。
代码如下：
package sina;
/**
* @author smile_tina
*
*/
public class Problem1 {
public boolean findNum(int[] nums, int num) {
if (null == nums)
return false;
return findNumSub(nums, num, 0, nums.length - 1);
}
public boolean findNumSub(int[] nums, int num, int left, int right) {
if (left > right)
return false;
int mid = left + (right - left) / 2;
if (nums[mid] == num) {
return true;
} else if (nums[mid] > num)
return findNumSub(nums, num, left, mid - 1);
else
return findNumSub(nums, num, mid + 1, right);
}
public static void main(String[] args) {
int[] a = { 1, 2, 3, 4, 5, 6, 7 };
Problem1 po = new Problem1();
System.out.println(po.findNum(a, 8));
}
}
2、第二题
题目描述
假设有一个整型数组，里面有若干数字，要求统计出一共有多少种不同的数字，并将这些数字保存到一个新的数组中，且根据数字出现的频率从少到多排列，如果频率相同则按数字值从小到大排列。
题目分析
使用Hashmap存储对应数字出现的频数，key是数字，value是该数字出现的次数。然后根据value值进行排序。
解决方法：
输入数组，map存储数字以及出现的次数，然后重写Collections的sort函数，按value值进行排序，输出不同数字的个数，result为所求新数组。
package sina;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
*
* @author smile_tina
*
*/
public class Problem2 {
/**
*
* @param nums 输入数组
* @return 按要求输出新数组
*/
public int[] distinctNum(int[] nums) {
HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
// fill map
for (int i = 0; i < nums.length; i++) {
if(map.containsKey(nums[i])){
map.put(nums[i], map.get(nums[i])+1);
}else
map.put(nums[i], 1);
}
//根据value值进行排序
List<Map.Entry<Integer, Integer>> info = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());
Collections.sort(info,new Comparator<Map.Entry<Integer, Integer>>() {
@Override
public int compare(Entry<Integer, Integer> o1,
Entry<Integer, Integer> o2) {
return o1.getValue()-o2.getValue();
}
});
System.out.println("一共有"+info.size()+"种不同的数字");
int[] result = new int[info.size()];
for(int i = 0;i<info.size();i++){
result[i] = info.get(i).getKey();
}
return result;
}
public static void main(String[] args) {
Problem2 po = new Problem2();
int[] a = {1,2,6,4,2,1,8,9,3,6,7};
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(po.distinctNum(a)));
}
}
3、第三题
题目描述
假设有一个字符串数组，每一个字符都是一个数字（1-9），找到其中的最大递增数，递增数是指相邻的数位从小到大排列的数字，如：28953456323，递增数有：289，3456，23，那么最大的递增数为3456。
题目分析
该题是个动态规划问题。
如果严格按照动态规划的步骤去解，在字符串长度为n的情况下需要存储n个字符串。但是我们可以发现如下规律，如果str[m:n]是严格递增的，则他的子集str[p:q] (p大于等于m 并且小于等于n) 一定是严格递增的，而且如果str[m] < str[m-1] 并且 str[n] > str[n+1] （未考虑边界条件），则str[m:n]一定是字符串m到n索引中值最大的字符串，有了这个规律，我们只需要从头往后遍历一次：用一个索引start表示当前正在遍历的递增字符串的初始位置，用一个变量res来存储之前最大的字符串，每当发现一个局部递增的字符串就和res比较一次（比较的规则是：如果str1的长度大于res的长度，则str1大，如果长度相等则比较字符串第一个位置），同时索引tmpIndex增加这个递增字符串的长度，否则一旦不连续，更新初始位置也就是start的值。这样当tmpIndex到达字符串末尾的时候，就得到了最大字符串。
解决方法
代码如下：
package sina;
/**
*
* @author smile_tina
*
*/
public class Problem3 {
public String findMaxNum(String str) {
if (null == str || str.length() == 0)
return "";
String res = "";
int start = 0;
int tmpIndex = start;
for (int i = 1; i < str.length(); i++) {
if (str.charAt(i) - str.charAt(tmpIndex) == 1) {
tmpIndex++;
if ((tmpIndex - start+1) > res.length())
res = str.substring(start, tmpIndex + 1);
if((tmpIndex - start + 1== res.length()) && str.charAt(start)>res.charAt(0))
res = str.substring(start, tmpIndex + 1);
}
else{
start = i;
tmpIndex = start;
}
}
return res;
}
public static void main(String[] args) {
Problem3 po = new Problem3();
System.out.println(po.findMaxNum("209876543210243423243242382648327493274832784123456789"));
}
}