网易游戏面试题目：25个速度不同的赛车，有一个5个车道的赛道可供比赛（不提供秒表），最少经过几次比赛，得到开的速度最快的赛车？

此题目换汤不换药，阿里巴巴的题目，个体可以为赛车、赛马、人。
可以作为思维题，也可以为算法编程题，笔试代码题，面试代码题（手写）和思维题（口述）。

第一步

将25个赛车分为5组，每组5个赛车，分别比赛，得出每组的第一名，并对第一名进行排序，为A1, B1, C1, D1, E1；

组编号	赛车
1	A1、A2、A3、A4、A5
2	B1、B2、B3、B4、B5
3	C1、C2、C3、C4、C5
4	D1、D2、D3、D4、D5
5	E1、E2、E3、E4、E5

第二步

A1, B1, C1, D1, E1进行一次比赛，得出第一名，假设为A1，此时经过6轮比赛，得出第一名；

第三步

找第二名第三名；首先第一步中D1, E1排除，同时排除对应组所有赛车；剩A1, B1, C1三组

第四步

第二名可能赛车是A2，B1； 第三名可能赛车是A2，A3, B1，B2, C1

第五步

最后将A2，A3, B1，B2, C1进行一轮比赛，得出第二名第三名，此时总共经过7轮比赛；

比赛次数	赛车
1	A1、A2、A3、A4、A5
2	B1、B2、B3、B4、B5
3	C1、C2、C3、C4、C5
4	D1、D2、D3、D4、D5
5	E1、E2、E3、E4、E5
6	A1、B1、C1、D1、E1
7	A2、A3、 B1、B2、C1

编程

Java代码
转载——wesleyJava博主给出的解答

package org.algorithm.search;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.Stack;

/**
 * @author yuewei.wangyw
 */
public class FindFastestHorse {

    /** 跑的次数 **/
    public static int times = 0;

    /**
     * 获得最快的那一匹
     * 
     * @param rootHorse 虚拟节点（最快的那一匹马）
     * @param runWaySize 跑道个数
     * @return
     */
    public static Horse findMax(Horse rootHorse, int runWaySize) {
        // 跑道
        List<Horse> runWay = new ArrayList<Horse>();
        // 比rootHorse 慢的马
        List<Horse> slowerHorses = rootHorse.getSlowerHorses();
        // 附加的比较的马匹，当比rootHorse 慢的马分组不够是，需要找更慢的马，进行比较，从而减少比较次数
        List<Horse> additionHorses = new ArrayList<Horse>();
        // 堆栈，用来实现查找下一匹马的递归实现
        Stack<Horse> stack = new Stack<Horse>();
        // 跑道个数
        int size = runWaySize;
        // 直到找到最快的马
        while (slowerHorses.size() > 1) {
            // 清除跑道
            runWay.clear();
            // 清除栈
            stack.clear();
            // 重置
            size = runWaySize;
            // 对比当前rootHorse慢的马进行分组
            for (Iterator<Horse> iter = slowerHorses.iterator(); iter.hasNext() && size-- > 0;) {
                Horse horse = iter.next();
                runWay.add(horse);
                stack.add(horse);
                iter.remove();
            }
            // 一旦分组不够，则取更慢的马
            if (size > 0) {
                // 要么已经选够了马，要么没有马可以选
                while (size > 0 && stack.size() > 0) {
                    Horse currentNode = stack.pop();
                    // 选更慢的马
                    for (Iterator<Horse> iter = currentNode.getSlowerHorses().iterator(); iter.hasNext() && size-- > 0;) {
                        Horse horse = iter.next();
                        additionHorses.add(horse);
                        stack.add(horse);
                        iter.remove();
                    }
                }
                // 更慢的马，加入到比赛队列
                runWay.addAll(additionHorses);
            }
            // 开始赛马
            Collections.sort(runWay);
            times++;
            // 建立马匹之间的关系
            for (int i = 0; i < runWay.size() - 1; i++) {
                runWay.get(i).getSlowerHorses().add(runWay.get(i + 1));
            }
            // 将当前比较队列中最快的马，加入到比rootHorse慢的马队中
            slowerHorses.add(runWay.get(0));
            System.out.println(">>>>第" + times + "次:");
            rootHorse.print();
        }
        // 得到最快的马，堆排序算法
        return slowerHorses.get(0);
    }

    /**
     * @param rootHorse
     * @param runWaySize 跑道个数
     * @param maxCount 最快马的个数
     */
    public static void find(Horse rootHorse, int runWaySize, int maxCount) {
        int i = 1;
        while (maxCount-- > 0) {
            rootHorse = findMax(rootHorse, runWaySize);
            System.out.println("--------第" + i++ + "名:" + rootHorse.getValue());

        }
    }

    public static void main(String args[]) {
        List<Horse> horses = Race.getHourses();
        for (int i = 0; i < horses.size(); i++) {
            System.out.print(horses.get(i).getValue());
            System.out.print(" ");
        }
        Horse horse = new Horse();
        horse.setValue(100);
        horse.setSlowerHorses(horses);
        System.out.println(" ");
        find(horse, 5, 3);
    }
}

/**
 * 赛马对象数据结构
 * 
 * @author yuewei.wangyw
 */
class Horse implements Comparable<Horse> {

    private int         value;
    private List<Horse> slowerHorses;

    public Horse(){
        slowerHorses = new ArrayList<Horse>();
    }

    public List<Horse> getSlowerHorses() {
        return slowerHorses;
    }

    public void setSlowerHorses(List<Horse> slowerHorses) {
        this.slowerHorses = slowerHorses;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public int compareTo(Horse o) {
        if (o.value > this.value) {
            return 1;
        } else if (o.value < this.value) {
            return -1;
        } else {
            return 0;
        }
    }

    private void print(int level) {
        for (int i = 0; i < level; i++) {
            System.out.print("| ");
        }
        System.out.print("+");
        System.out.println(value);
        for (int i = 0; i < slowerHorses.size(); i++) {
            slowerHorses.get(i).print(level + 1);
        }
    }

    public void print() {
        print(0);
    }
}

/**
 * 生成马队
 * 
 * @author yuewei.wangyw
 */
class Race {

    public static List<Horse> getHourses() {
        List<Horse> hourses = new ArrayList<Horse>();
        Random random = new Random();
        random.setSeed(100);
        int rad = 0;
        Set<Integer> set = new HashSet<Integer>();
        while (hourses.size() < 25) {
            rad = random.nextInt(1024) % 25;
            if (!set.contains(rad)) {
                set.add(rad);
                Horse horse = new Horse();
                horse.setValue(rad + 1);
                hourses.add(horse);
            }

        }
        return hourses;
    }
}