面试题目——《CC150》排序与查找

面试题11.1：给定两个排序后的数组A和B，其中A的末端有足够的缓冲空间容纳B。编写一个方法，将B合并入A并排序。

package cc150.sort_search;

public class MergeTwoSortedArr {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int[] a = {1,3,5,7,9,11,13,15,0,0,0,0,0,0,0,0};
		int[] b = {0,2,4,6,8,10,12,14};
		MergeTwoSortedArr mt = new MergeTwoSortedArr();
		mt.merge(a,b,8,8);
		for(int i=0;i<a.length;i++)
			System.out.println(a[i]);
	}

	public void merge(int[] a,int[] b,int lastA,int lastB){
		int indexA = lastA-1;
		int indexB = lastB-1;
		int indexMerge = lastA+lastB-1;
		//递减循环
		while(indexA >= 0 && indexB >= 0){
			if(a[indexA] > b[indexB])	{	//如果数组A的元素大于数组B的元素，先放入A
				a[indexMerge] = a[indexA];
				indexA--;
				indexMerge--;
			}else{
				a[indexMerge] = b[indexB];
				indexB--;
				indexMerge--;
			}
		}
		//如果B还有元素没有放进去的话，继续放，A不用，因为仍然在原来的位置
		while(indexB >= 0){
			a[indexMerge] = b[indexB];
			indexB--;
			indexMerge--;
		}
	}

}

面试题11.2：编写一个方法，对字符串数组进行排序，将所有变位词排在相邻的位置。

package cc150.sort_search;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Hashtable;
import java.util.Iterator;

public class AnagramSort {

	//牛客网题目中要求变位词的字典排序最小的数的集合，且这个集合也要是字典排序的
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		AnagramSort as = new AnagramSort();
		String[] arr = {"ab","ba","abc","cba"};
		Iterator ire = as.sortStrings(arr).iterator();
		while(ire.hasNext())
			System.out.println(ire.next());
	}

	public String sortChars(String str) {		//把字符串排序后返回
		char[] content = str.toCharArray();
		Arrays.sort(content);
		return new String(content);
    }

	public ArrayList<String> sortStrings(String[] array){
		Hashtable<String,ArrayList<String>> hash = new Hashtable<String,ArrayList<String>>();
		ArrayList<String> anagrams = new ArrayList<String>();	//存放每个变位词集合
		ArrayList<String> result = new ArrayList<String>();			//存放每个变位词集合排序后的第一个
		//将同为变位词的单词分到同一组
		for(String s:array){
			String key = sortChars(s);
			if(!hash.containsKey(key)){
				hash.put(key, new ArrayList<String>());	//如果不包含变位词，建立key对应的链表
			}
			anagrams = hash.get(key);	//取得链表，并往其中加入变位词
			anagrams.add(s);						//加入变位词
		}

		//将散列表排序后转换成ArrayList
		for(String key:hash.keySet()){							//取得key的集合，并遍历
			ArrayList<String> list = hash.get(key);		//一个一个取得ArrayList
	        Collections.sort(list,new Comparator<String>(){
	            @Override
	            public int compare(String str1, String str2) {
	                // TODO Auto-generated method stub
	                    return str1.compareTo(str2);
	            }
	        });
			result.add( list.get(0));		//取得排序后的每个变位词集合的第一个元素，加入新的链表中
			Collections.sort(result,new Comparator<String>(){	//把新的链表排序后返回
	            @Override
	            public int compare(String str1, String str2) {
	                // TODO Auto-generated method stub
	                    return str1.compareTo(str2);
	            }
	        });
		}
		return result;
	}

}

面试题11.3：给定一个排序后的数组，包含n个整数，但这个数组已被旋转过很多次，次数不详。请编写代码找出数组中的某个元素。可以假定数组元素原先是按从小到大的顺序排列的。

　　旋转的意思是：Array1:{10,15,20,0,5}中有一半是升序排序的

package cc150.sort_search;

public class Search {

	//注意可能有重复的元素
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int[] a = {2,2,2,3,4,2};
		Search s = new Search();
		System.out.println(s.search(a,0,a.length-1,3));
	}

	public int search(int a[],int left,int right,int x){		//查找x
		int mid = (left+right)/2;
		if(x == a[mid])		//找到元素
			return mid;
		if(right < left)		//没找到元素
			return -1;
		//二分查找
		if(a[left] < a[mid]){								//左半边正常排序
			if(a[left] <= x && a[mid] >= x)		//x在左半边的范围内
				return search(a,left,mid-1,x);
			else													//x不在左半边的范围内
				return search(a,mid+1,right,x);
		}else if(a[left] > a[mid]){					//右半边正常排序
			if(a[mid] <= x && a[right] >= x)	//x在右半边的范围内
				return search(a,mid+1,right,x);
			else													//x不在右半边的范围内
				return search(a,left,mid-1,x);
		}else if(a[left] == a[mid]){				//左半边都是重复元素，{2,2,2,3,4,2}的情况
			if(a[mid] != a[right])						//如果右边不等于中间，只需要搜索左半边
				return search(a,left,mid-1,x);
			else{													//否则两边都要搜索
				int result = search(a,left,mid-1,x);		//先搜索左半边
				if(result == -1)				//如果没有搜索到
					return  search(a,mid+1,right,x);		//再搜索右半边
				else
					return result;
			}
		}
		return -1;
	}

}

面试题11.4：设想你有一个20GB的文件，每一行一个字符串。请说明将如何对这个文件进行排序。

　　在不能全部载入内存的情况下，使用外部排序，看《数据结构与算法分析》

面试题11.5：有一个排序后的字符串数组，其中散步着一些空字符串，编写一个方法，找出给定字符串的位置。

package cc150.sort_search;

public class Finder {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Finder fd = new Finder();
		String[] arr = {"a","b","","c","","d"};
		System.out.println(fd.findString(arr, 6, "c"));
	}

	//因为是有序数组，所以使用二分查找，但是有空字符串，所有当mid遇到空字符串的时候要转到最近的非空字符串
	public int findString(String[] str, int n, String x) {
        // write code here
		if(str == null || str == null || str.length <= 0)
			return -1;
		return searchR(str,x,0,n-1);
    }

	public int searchR(String[] strings,String str,int first,int last){
		if(first > last)
			return -1;
		int mid = (first+last)/2;
		//如果mid是空的情况
		if(strings[mid].isEmpty()){
			int left = mid-1;
			int right = mid+1;
			while(true){		//循环
				if(left < first &&right > last)		//返回错误
					return -1;
				else if(right <= last && !strings[right].isEmpty()){	//如果mid的右边不超过last，且不为空的话，赋值为mid，跳出
					mid = right;
					break;
				}else if(left >= first && !strings[left].isEmpty()){	//如果mid的左边不超过last，且不为空的话，赋值为mid，跳出
					mid = left;
					break;
				}
				right++;
				left--;
			}
		}
		//对不为空的mid进行检查
		if(str.equals(strings[mid]))
			return mid;
		else if(strings[mid].compareTo(str)<0)		//mid小于str，对右半边继续二分查找
			return searchR(strings,str,mid+1,last);
		else
			return searchR(strings,str,first,mid-1);
	}

}

面试题11.6：给定M×N矩阵，每一行、每一列都按升序排列，请编写代码找出某元素。

package cc150.sort_search;

public class FindElement {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

	}

	public int[] findElement(int[][] mat, int n, int m, int x) {
        // write code here
		int row = 0;
		int column = m-1;
		while(row < n && column >= 0){	//从右上角开始寻找
			if(mat[row][column] == x){
				int[] result = {row,column};
				return result;
			}else if(mat[row][column] > x)
				column--;
			else
				row++;
		}
		return null;
    }

}

面试题11.7：有一个马戏团正在设计叠罗汉的表演节目，一个人要站在另一个人的肩膀上。出于实际和美观的考虑，在上面的人要比下面的人矮一点、轻一点。已知马戏团每个人的高度和重量，请编写代码计算叠罗汉最多能叠到几个人。（最长递增子序列）

package cc150.sort_search;

public class Dieluohan {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根

	}

	public int getHeight(int[] men, int n) {	//建立一个数组记录每一位的时候最长序列的长度
        // write code here
		int[] dp = new int[n];		//存放到达每一位的时候的最长序列的长度
		int max = 0;
		for(int i=0;i<n;i++){
			dp[i] = 1;	//先把每一个置为1，因为至少是1
			for(int j=0;j<i;j++){	//加上了第i个后，循环前i-1个，如果有值小于等于第i个值的话，加上1，注意加上i后最长的
				if(men[j] <= men[i])
					dp[i] = Math.max(dp[i], dp[j]+1);
			}
			max = Math.max(dp[i], max);
		}
		return max;
    }

}