【算法题集锦之一】--给定只能排序5个数的方法，找出25个数中的前四个
转眼间大学毕业了，找工作的过程不是很顺利，虽然也面过几家知名的互联网企业（阿里，PPTV等）且坚持到了终面，但还是以失败告终，除了运气成分之外，更多的还是因为自己的算法钻研的不够深，故产生了这个想法：通过写一系列关于算法的博客来提高自己的算法水平，希望自己能坚持下去。
这道题目是我在面试PPTV时，面试官出的一道题，据说是原百度的校招题：即25匹赛马，只有五条跑道，问需要比赛几次才能确定前5匹马。
不过面试官换了一种描述：
给定一个方法sort，每次最多排序5个数，
只使用该排序方法，给定25个无序的数，
问需要调用sort方法几次可以得到前4个数。
这道题难度适中，不算很难，一般都能得到一种解法，但是得到最优解还是要思考一下的。
25个数需要得到前4个数，不管怎样这25个数肯定都要比较一遍，所以第一步的话很容易想到：将25个数分成五组，对五组分别进行排序，得到五组有序的数组。
比较容易想到的一种解法如下：
5组数组都已经有序了，每一组的最大数都是已知了，接下来只需要取每组的第一个数进行排序，就能获得一个要求的数（逐个获取最大的数），去除这个数，然后再如此反复比较（即每一次都取每组中的第一个数进行排序，就能依次获得第二个数，第三个数，和第四个数），这样总共需要9次排序。下面的图说明了一种可能出现的排序情况
同理，最后一次排序（即第九次排序）也是重复这个过程，到第九次就可以获得前四个数了。
当然，九次排序明显不是最优解，因为在这九次排序中我们做了多余的比较，注意到题目只需要取前四个数，当第六次排序后。我们就可以排除掉一些不可能的数据，很显然，第五组中的数是可以排除的，因为第五组中最大的数也只可能是第五大的数（前四组的第一个数都比它大），同理，第四组的后四个数也是不可能的，第三组的最后三个，第二组的最后两个和第一组的最后一个数，这些数都可以排除。
排除了这些数以后，我们就可以减少排序次数了，第六次排序后可以排除：1、已经确定的最大的数 2、上面列举出来的数（共15个）
这样第六次排序后还需要比较的数只剩下9个了，如下图。
剩下的9个数中还需要比较出前三个数来，只需要两次排序即可。
第七次排序，取第一组的第一个，第一组的第二个，第二组的第一个、第三组的第一个和第四组的第一个进行排序。第七次排序后可以排除最后两个数字所在组的所有数（因为只需要前三个）。
因为第二组的第一个数、第三组的第一个数和第四组的第一个数是有序的，所以最后两个数只可能有三种情况：1、都属于第一组
2、第三组和第四组
3、第一组的第二个数和最后一组
这样经过七次排序可以排除至少三个数，加上第七次排序找出来的第二大的数，可以排除4个数，则只剩下5个数，再进行一次排序即可，总共八次排序。
下面是用代码实现的过程（java），以快排作为给定的排序方法。
package test;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Test {
/**
* 快排
* @param num
*/
public static void sort(int[] num, int low, int high){
if(low < high){
// 获得中轴位置
int middle = hoare(num, low, high);
// 左边排序
sort(num, low, middle - 1);
// 右边排序
sort(num, middle + 1, high);
}
}
/**
* 快排核心算法
* @param num 数组
* @param low 低位指针
* @param high 高位指针
* @return
*/
public static int hoare(int[] num, int low, int high){
int key = num[low];//最低位为关键数
while(low < high){
// 高位指针一直递减 直到遇见比key小的数
while(num[high] <= key && low < high){
high --;
}
// 把高位小的数移到低位
num[low] = num[high];
// 低位指针一直递加 直到遇见比key大的数
while(num[low] >= key && low < high){
low ++;
}
// 把低位大的数移到高位
num[high] = num[low];
}
// 当循环停止（即low == high）的时候，到达中轴位置，中轴位置的值置为key
num[low] = key;
// 返回中轴位置
return low;
}
/**
* 问题描述：
* 给定一个方法sort，每次最多排序5个数，
* 只使用该排序方法，给定25个无序的数，
* 问最少调用sort方法几次可以得到前四个数
* @param args
*/
public static void main(String[] args) {
int[] num = new int[25];
// 随机生成25个数
for(int i = 0; i < 25; i ++){
num[i] = new Random().nextInt(100);
}
System.out.println("未排序的情况");
for(int i = 0; i < 5; i ++){
System.out.print("第" + (i+1) + "组：");
for(int j = i * 5; j < (i + 1) * 5; j ++)
System.out.print(num[j] + " ");
System.out.println();
}
// 分五组排序（前五次）
for(int i = 0; i < 5; i ++){
sort(num, i * 5, (i * 5 + 4));
}
// 记录每一组最大数的位置
Map map = new HashMap();
map.put(num[0], 0);
map.put(num[5], 5);
map.put(num[10], 10);
map.put(num[15], 15);
map.put(num[20], 20);
System.out.println("前五次排序后的情况");
for(int i = 0; i < 5; i ++){
System.out.print("第" + (i+1) + "组：");
for(int j = i * 5; j < (i + 1) * 5; j ++)
System.out.print(num[j] + " ");
System.out.println();
}
// 第六次排序（取五组的最大的数排序）
int[] temp = {num[0], num[5], num[10], num[15], num[20]};
sort(temp, 0, 4);
// 本次排序后可以排除第五组全部数字、第四组最后四个，
// 第三组最后三个，第二组最后两个，第一组最后一个。
// 取得每一组的第一个数在原数组中的位置
int indexOfFirst = map.get(temp[0]);
int indexOfSecond = map.get(temp[1]);
int indexOfThird = map.get(temp[2]);
int indexOfForth = map.get(temp[3]);
int indexOfFifth = map.get(temp[4]);
// 第六次排序后的情况
System.out.println("第六次排序未排除数后的情况：");
System.out.println("第1组："+ num[indexOfFirst] + " "
+ num[indexOfFirst + 1] + " " + num[indexOfFirst + 2]
+ " " + num[indexOfFirst + 3] + " " + num[indexOfFirst + 4]);
System.out.println("第2组："+ num[indexOfSecond] + " "
+ num[indexOfSecond + 1] + " " + num[indexOfSecond + 2]
+ " " + num[indexOfSecond + 3] + " " + num[indexOfSecond + 4]);
System.out.println("第3组："+ num[indexOfThird] + " "
+ num[indexOfThird + 1] + " " + num[indexOfThird + 2]
+ " " + num[indexOfThird + 3] + " " + num[indexOfThird + 4]);
System.out.println("第4组："+ num[indexOfForth] + " "
+ num[indexOfForth + 1] + " " + num[indexOfForth + 2]
+ " " + num[indexOfForth + 3] + " " + num[indexOfForth + 4]);
System.out.println("第5组："+ num[indexOfFifth] + " "
+ num[indexOfFifth + 1] + " " + num[indexOfFifth + 2]
+ " " + num[indexOfFifth + 3] + " " + num[indexOfFifth + 4]);
// 第六次排序后的情况
System.out.println("第六次排序排除数后的情况：");
System.out.println("第1组：" + num[indexOfFirst + 1] + " " +
num[indexOfFirst + 2] + " " + num[indexOfFirst + 3]);
System.out.println("第2组：" + num[indexOfSecond] + " " +
num[indexOfSecond + 1] + " " + num[indexOfSecond + 2]);
System.out.println("第3组：" + num[indexOfThird] + " " +
num[indexOfThird + 1]);
System.out.println("第4组：" + num[indexOfForth]);
// 第六次排序后可以得到最大的数---即第一组的第一个数
int first = num[indexOfFirst];
int second;
// 剩余的数分布情况
// 第一组的三个数（第一个数已经确定为最大）
// t1: {num[indexOfFirst + 1], num[indexOfFirst + 2], num[indexOfFirst + 3]};
// 第二组的前三个
// t2: {num[indexOfSecond], num[indexOfSecond + 1], num[indexOfSecond + 2]};
// 第三组的前两个
// t3: {num[indexOfThird], num[indexOfThird + 1]};
// 第三组的第一个
// t4: {num[indexOfForth]};
// 现在只剩下9个数，要得到这9个数中前三个，还需两次排序即可
// 理由：
// 第七次排序，取第一组的第一个，第一组的第二个，第二组的第一个、第三组的第一个和第四组的第一个进行排序
// 第七次排序后可以排除最后两个数字所在组的所有数（因为只需要前三个）
// 又第二组的第一个（num[indexOfSecond]）、第三组的第一个（num[indexOfThird]）
// 第四组的第一个（num[indexOfForth]）是有序的，最后两个数中不可能有第二组的数，
// 所以排序完后最后两个数只可能有三种情况。
// 1、都属于第一组 2、第三组和第四组 3、第一组的第二个数（num[indexOfFirst + 2]）和最后一组
// 其他情况都是不可能的，这三种情况都能排除至少3个数，加上第七次排序得到的最大数（即第二大的数），
// 则剩下的数最多只有5个，再一次排序即可
// 记录接下来要排序的五个数属于哪一组
map.put(num[indexOfFirst + 1], 1);// 第一组的第一个
map.put(num[indexOfFirst + 2], 1); // 第一组的第二个
map.put(num[indexOfSecond], 2); // 第二组的第一个
map.put(num[indexOfThird], 3); // 第三组的第一个
map.put(num[indexOfForth], 4); // 第四组的第一个
temp = new int[]{ num[indexOfFirst + 1],
num[indexOfFirst + 2],
num[indexOfSecond],
num[indexOfThird],
num[indexOfForth]
};
//第七次排序
sort(temp, 0, 4);
//第七次排序后可以排除剩余两个数所在组的全部数字，
//且可以找出第二大的数，即这五个数中的第一个
second = temp[0];
//获得最后两个数所在的组
int groupOfForth = map.get(temp[3]);
int groupOfFifth = map.get(temp[4]);
//第一个数所在的组
int groupOfFirst = map.get(temp[0]);
// 第一种情况：都属于第一组
if(groupOfForth == 1 && groupOfFifth == 1){
//最后两个数都属于第一组，则最大数是第二组的第一个，即num[indexOfSecond]
//排除第一组的所有数字和第二组的第一个，剩余的数为第二组的第二、三个
//第三组所有、第四组所有
temp = new int[]{num[indexOfSecond + 1],
num[indexOfSecond + 2],
num[indexOfThird],
num[indexOfThird + 1],
num[indexOfForth]};
// 第八次排序，取前两个数即可
sort(temp, 0, 4);
}
// 第二种情况 、最后两个数属于第三组和第四组
else if(groupOfForth == 3 && groupOfFifth == 4){
//排除第三组和第四组的数
//第一个数有可能属于第一组的第一个，或者第二组的第一个
if(groupOfFirst == 1){
//如果第一个数属于第一组的第一个，则剩余要排序的数是第一组的后两个
//第二组的全部
temp = new int[]{num[indexOfFirst + 2],
num[indexOfFirst + 3],
num[indexOfSecond],
num[indexOfSecond + 1],
num[indexOfSecond + 2],
};
// 第八次排序
sort(temp, 0 , 4);
} else if(groupOfFirst == 2){
//如果第一个数属于第二组第一个，则剩余要排序的数为第一组的全部
//第二组的剩余两个数
temp = new int[]{num[indexOfFirst + 1],
num[indexOfFirst + 2],
num[indexOfFirst + 3],
num[indexOfSecond + 1],
num[indexOfSecond + 2],
};
// 第八次排序
sort(temp, 0 , 4);
}
}
// 第三种情况，最后两个数是第一组的第二个和最后一组
else if((groupOfForth == 1 && groupOfFifth == 4) ||
(groupOfForth == 4 && groupOfFifth == 1)){
//排除第一组的后三个数和第四组的数
//第一个数有可能属于第一组的第一个，或者第二组的第一个
if(groupOfFirst == 1){
//如果第一个数属于第一组的第一个，则剩余要排序的数是第二组的全部
//第三组的全部
temp = new int[]{num[indexOfSecond],
num[indexOfSecond + 1],
num[indexOfSecond + 2],
num[indexOfThird],
num[indexOfThird + 1],
};
// 第八次排序
sort(temp, 0 , 4);
} else if(groupOfFirst == 2){
//如果第一个数属于第二组第一个，则剩余要排序的数为第一组的第一个
//第二组的剩余两个数，和第三组的全部
temp = new int[]{num[indexOfFirst + 1],
num[indexOfSecond + 1],
num[indexOfSecond + 2],
num[indexOfThird],
num[indexOfThird + 1],
};
// 第八次排序
sort(temp, 0 , 4);
}
}
System.out.println("前四个数已找到，分别为：" +
first + " " +
second + " " +
temp[0] + " " +
temp[1]);
}
}