统计回文：“回文串”是一个正读和反读都一样的字符串；寻找第K大：有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。

1.选择题

1. 要使对象具有序列化能力，则其类应该实现如下哪个接口()。
   A java.io.Serializable
   B java.lang.Cloneable,
   C java.lang.CharSequence
   D java.lang.Comparable

答案：A
解析：

b.Java中，一个类要实现clone功能，必须实现 Cloneable接口，则就要引入该包
c.字符序列接口,实现此接口的非抽象类有String, StringBuffer, StringBuilder。从结果来讲, 该接口的主要作用就是使得三者之间在进行一部分操作(比如查找, 比较)时变得容易。
d.comparable是通用的接口，用户可以实现它来完成自己特定的比较。

2.关于下列程序段的输出结果，说法正确的是：（ ）
public class MyClass{
static int i;
public static void main(String argv[]){
System.out.println(i);
} }
A 有错误，变量i没有初始化。
B null
C 1
D 0

答案：D
解析：

类变量在不设置初始值时，会进行默认值赋值，而局部方法中声明的变量则必须进行初始化，他不会进行默认值赋值。

3.关于被私有访问控制符private修饰的成员变量，下列说法正确的是（ ）。

A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的
B．可以被两种类访问和引用：该类本身、该类的所有子类
C．只能被该类自身所访问和修改
D．只能被同一个包中的类访问
答案：C
解析：

java有四种访问类型，分别为public，protected，default和private，其
中public变量可以被所有的外部类访问，而pretected变量可以被同一个包及该类的子类访问，default变量即没有任何修饰符的变量可以被同一个包中的类访问，而private变量 只能在被该类内部被访问。题目中的外部类应该理解为除该类自身的其他类。

4.Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( ).
A 11 ,-11
B 11 ,-12
C 12 ,-11
D 12 ,-12
答案：C
解析：

Math类中为我们提供了三个与取整有关的方法ceil(向上取整)、floor(向下取整)、round(四舍五入)：
①.向上取整ceil()：该小数的小数部分只要大于0，就取 该小数的右边的第一个整数，等于0则取该数的整数部分
②.向下取整floor(): 该小数的小数部分只要大于0，就取 该小数的左边的第一个整数,等于0则取该数的整数部分
③.四舍五入round():该小数加 0.5 后如果是一个整数，则取该数，否则取 该小数左边的第一个整数.

2.统计回文

题目描述：https://www.nowcoder.com/questionTerminal/9d1559511b3849deaa71b576fa7009dc

“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。花花非常喜欢这种拥有对称美的回文串，生日的时候她得到两个礼物分别是字符串A和字符串B。现在她非常好奇有没有办法将字符串B插入字符串A使产生的字符串是一个回文串。你接受花花的请求，帮助她寻找有多少种插入办法可以使新串是一个回文串。如果字符串B插入的位置不同就考虑为不一样的办法。
例如：
A = “aba”，B = “b”。这里有4种把B插入A的办法：

• 在A的第一个字母之前: “baba” 不是回文
• 在第一个字母‘a’之后: “abba” 是回文
• 在字母‘b’之后: “abba” 是回文
• 在第二个字母’a’之后 “abab” 不是回文
  所以满足条件的答案为2

输入描述

每组输入数据共两行。
第一行为字符串A
第二行为字符串B
字符串长度均小于100且只包含小写字母

输出描述

输出一个数字，表示把字符串B插入字符串A之后构成一个回文串的方法数

示例：
输入：
aba
b
输出：
2

代码实现：

import java.util.Scanner;
public class Mian2 {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            //输入两个字符串
            String str1 = sc.nextLine();
            String str2 = sc.nextLine();
            //计算插入i位置是回文串的次数
            int count = 0;
            //也可以插入最后一个字符的后面，所以必须要带等号
            for(int i = 0;i <= str1.length();i++) {
            //对于经常修改的字符串，考虑用StringBuffer
                StringBuffer str = new StringBuffer(str1);
            //表示在i位置插入str2字符串
                str.insert(i,str2);
            //如果插入后str是回文字符串，则计数器＋1
                if(IsHuiWen(str.toString())) {
                    count++;
                }
            }
            System.out.println(count);
        }
        public static boolean IsHuiWen(String str) {
            int i = 0;
            int j = str.length() - 1;
            while(i < j) {
                if(str.charAt(i) != str.charAt(j)) {
                    return false;
                }
                i++;
                j--;
            }
            return true;
        }
    }

3.寻找第K大

题目描述：https://www.nowcoder.com/questionTerminal/e016ad9b7f0b45048c58a9f27ba618bf

有一个整数数组，请你根据快速排序的思路，找出数组中第K大的数。
给定一个整数数组a,同时给定它的大小n和要找的K(K在1到n之间)，请返回第K大的数，保证答案存在。

示例1
输入：
[1,3,5,2,2],5,3
输出：
2

解题思路：

这题应该是用快排的思想：例如找49个元素里面第24大的元素，那么按如下步骤： 1.进行一次快 排（将大的元素放在前半段，小的元素放在后半段）,假设得到的中轴为p 2.判断 p - low + 1 == k ，如果成立，直接输出a[p]，（因为前半段有k - 1个大于a[p]的元素，故a[p]为第K大的元素） 3. 如果 p - low + 1> k， 则第k大的元素在前半段，此时更新high = p - 1，继续进行步骤1 4.如果p - low + 1 < k， 则第k大的元素在后半段， 此时更新low = p + 1, 且 k = k - (p - low + 1)，继续步骤
由于常规快排要得到整体有序的数组，而此方法每次可以去掉“一半”的元素，故实际的复杂度不是o(nlgn), 而是o(n）

程序代码：

public class Finder {
    public int findKth(int[] a, int n, int K) {
        return findKth(a, 0, n - 1, K);
    }

    public int findKth(int[] a, int low, int high, int k) {
        int part = partation(a, low, high);
        if (k == part - low + 1) {
            return a[part];
        } else if (k > part - low + 1) {
            return findKth(a, part + 1, high, k - part + low - 1);
        } else {
            return findKth(a, low, part - 1, k);
        }
    }
    public int partation(int[] a, int low, int high) {
        int key = a[low];
        while(low < high) {
            while(low < high && a[high] <= key) high--;
            a[low] = a[high];
            while(low < high && a[low] >= key) low++;
            a[high] = a[low];
        } a
                [low] = key;
        return low;
    } 
}

关于寻找最大K的解法，我觉得下面这篇博文写的很好：
https://blog.csdn.net/orangefly0214/article/details/86527462?utm_medium=distribute.pc_relevant_t0.none-task-blog-searchFromBaidu-1.control&depth_1-utm_source=distribute.pc_relevant_t0.none-task-blog-searchFromBaidu-1.control