每日一题：day1

Day1:
链接：https://www.nowcoder.com/questionTerminal/9d1559511b3849deaa71b576fa7009dc
来源：牛客网

统计回文
“回文串”是一个正读和反读都一样的字符串，例如“ level”或者“ noon”等等就是回文串。花花非常喜欢这种拥有对称美的回文串，生日的时候她得到现在她非常好奇有没有办法将字符串B插入字符串A使产生的字符串是一个回文串。你接受花花的请求，帮助她寻找有多少如果插入B插入的位置不同就考虑为不一样的方法。
例如：
A =“ aba”，B =“ b”。这里有4种把B插入A的办法：
*在A的第一个字母之前：“ baba”不是回文
*在第一个字母’a’之后：“ abba”是回文
*在字母’b’之后：“ abba”是回文
*在第二个字母’a’之后“ abab”不是回文
所以满足条件的答案为2

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

输出描述：
输出一个数字，表示把字符串B插入字符串A之后构成一个回文串的方法数
示例1
输入
aba
b
输出
2

思路：
1、定义两个指针，一个从前往后走，一个从后往前走，若相等，则是回文，不相等不是回文
2、将str2按顺序插入str1中，调用回文函数查看是否为回文。若为回文，计数加一

代码：

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String str1=sc.nextLine();
            String str2=sc.nextLine();
            int count=0;
            for(int i=0;i<=str1.length();i++){
                StringBuilder sb=new StringBuilder(str1);
                sb.insert(i,str2);
                if(isHuiWen(sb.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;
    }
}

回文数
https://leetcode-cn.com/problems/palindrome-number/
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

class Solution {
    public boolean isPalindrome(int x) {
         if (x < 0) {
            return false;
        }
        String s = x + "";
        int left = 0;
        int right = s.length() - 1;
        while (left < right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

链接：https://www.nowcoder.com/questionTerminal/e016ad9b7f0b45048c58a9f27ba618bf
来源：牛客网

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

测试样例：
[1,3,5,2,2],5,3
返回：2

方法一：

import java.util.*;
public class Finder {
    public int findKth(int[] a, int n, int K) {
        PriorityQueue<Integer> min=new PriorityQueue<>();
        for(int i=0;i<n;i++){
            min.offer(a[i]);
            if(min.size()>K){
                min.poll();
            }
        }
        return min.peek();
    }
}

方法二：

import java.util.*;
public class Finder {
    public int findKth(int[] a, int n, int K) {
        if(n==0 || a==null){
            return -1;
        }
        Arrays.sort(a);
        return a[n-K];
    }
}

方法三：

这题应该是用快排的思想：例如找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)，继续步骤1. 由于常规快排要得到整体有序的数组，而此方法每次可以去掉“一半”的元素，故实际的复杂度不o(nlgn)
  , 而是o(n)。

class Solution {
    public int findKthLargest(int[] nums, int k) {
        if(nums==null || nums.length==0){
            return -1;
        }
        int low=0;
        int high=nums.length-1;
        return findKth(nums, low, high, 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;
    }
}