散列表

算法相关的面试题

１. 散列表

​ （１）什么是散列表？

​ 散列表（也称之为哈希表）是一种依据关键码值直接存取记录的数据结构（即依据关键码值的

​ hashcode（哈希码）定位到散列表中某个位置来进行存取）。

​ （２）工作原理：

​ （３）几个相关的类和接口

​ HashMap类：底层使用的是散列表。

​ 线程不安全，性能高。

​ Hashtable类：线程安全，性能比较低，少用。

​ ConcurrentHashMap类：线程安全，性能良好。

​ Collections.synchronizedMap(Map map):会返回一个线程安全的map。

​ TreeMap类：线程不安全，底层使用的是红黑树。性能比HashMap稍差，主要用在需要对

​ 关键码值排序的场合。

２.几个跟算法相关的面试题

​ （１）统计一个字符串当中各个大写字母的出现的次数。

​ 比如: “asdfFFDsdf123你好S”

​ 字符是一个数，就是该字符的unicode编码。

/**
 *  统计字符串当中大写字母出现的次数
 */
public class Demo2 {

    public static int[] countChar(String str){
        /*
            count用来存放各个字母出现的次数，其中
            下标０的位置存放'A'的次数，下标１的位置存
            放'B'的次数，依次类推。
         */
        int[] count = new int[26];
        for(int i = 0; i < str.length(); i ++){
            char c = str.charAt(i);
            //判断是否为一个大写字母
            if(c >= 'A' && c <= 'Z'){
                //这是一个大写字母，则将该字母出现的次数放到对应的位置
                count[c - 'A'] ++;
            }
        }
        return count;
    }
    public static void main(String[] args) {
        String str = "AEsasdfDDaASDF哈哈";
        int[] arr = countChar(str);
        //System.out.println(Arrays.toString(arr));
        char c = 'A';
        for(int i = 0; i < 26; i ++){
            System.out.println(c ++ +":" + arr[i]);
        }
    }
}

​ （２）将一个7进制数转换为整数（不用API）。

/**
 * 将一个字符串转换成对应进制的整数
 */
public class Demo3 {
    public static void test1(){
        String str = "123";
        System.out.println(Integer.parseInt(str,7));
        System.out.println(myParseInt(str,7));
    }

    /**
     * 将一个字符串转换成对应进制的整数
     * @param str 要转换的字符串
     * @param radix　进制
     * @return　对应的十进制整数   "123"
     */
    public static int myParseInt(String str,int radix){
        /*
            将各个位置上的基数拿到，然后按照如下公式进行计算:
            各个位置上的基数 * 权重，然后相加。
         */
        int sum = 0;
        //weight:权重
        int weight = 1;
        for(int i = str.length() - 1; i >=0; i --){
            //从最末一位开始进行计算
            char c = str.charAt(i);
            //将字符转换成数字
            int n = c - '0';
            sum += n * weight;
            weight *= radix;
        }
        return sum;
    }
    public static void main(String[] args) {
            test1();
    }
}

​ （３）将非常大量的一组数当中的前１００名找到。

注：二分查找

​ 什么是二分查找？

​ 在已排序的数据上实现的快速查找算法，每次查找可以排除一半的数据。

​ Arrays.binarySearch方法用于二分查找，该方法需要注意两个细节：

​ a. 如果有重复元素，则返回其中任意一个元素的位置。

​ b. 如果找不到对应的元素，则返回“－插入位置 -1"。

​

/**
 * 将非常大量的一组数当中的前１００名找到
 */
public class Demo5 {
    public static void main(String[] args) {
        /*
            这儿演示的是从１００个数当中找出前５个最大的，如果
            数更多，算法的逻辑是一样的
         */
        Random r = new Random();
        //arr始终存放最大的５个数
        int[] arr = new int[5];
        for(int i = 0; i < 100; i ++){
            //从１００个数中取一个数
            int n = r.nextInt(1000);
            //获得该数的插入位置
            int index = Arrays.binarySearch(arr,n);
            //如果该数小于或者等于当前最小值，则不用插入
            if(index == 0 || index == -1){
                continue;
            }
            //还原该数的实际插入位置
            if(index < 0){
                index = -(index + 1);
            }
            //移动元素（将最小的也就是下标等于０的元素移走）
            for(int j = 1; j < index; j ++){
                arr[j - 1] = arr[j];
            }
            //将该数插入
            arr[index - 1] = n;
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("arr:" + Arrays.toString(arr));
    }
}

​

​

​

​