leetcode38——所有回文字符，二叉搜索树的最接近K个值，数组中最接近x的k个值，论文因子

map：常用方法：
增：Put
删：remove(key)
查：containsKey,containsValue,get
char a:map.keySet
for(Map.Entry entry : map.entrySet()){
String mapKey = entry.getKey();
String mapValue = entry.getValue();
System.out.println(mapKey+":"+mapValue);
}
leetcode 267:
给定一个字符串 s ，返回其通过重新排列组合后所有可能的回文字符串，并去除重复的组合。
如不能形成任何回文排列时，则返回一个空列表。
示例 1：
输入: “aabb”
输出: [“abba”, “baab”]
示例 2：
输入: “abc”
输出: []

public class Solution {
    Set < String > set = new HashSet < > ();
    public List < String > generatePalindromes(String s) {
        int[] map = new int[128];
        char[] st = new char[s.length() / 2];
        if (!canPermutePalindrome(s, map))
            return new ArrayList < > ();
        char ch = 0;
        int k = 0;
        for (int i = 0; i < map.length; i++) {
            if (map[i] % 2 == 1)
                ch = (char) i;
            for (int j = 0; j < map[i] / 2; j++) {
                st[k++] = (char) i;
            }
        }
        permute(st, 0, ch);
        return new ArrayList < String > (set);
    }
    public boolean canPermutePalindrome(String s, int[] map) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            map[s.charAt(i)]++;
            if (map[s.charAt(i)] % 2 == 0)
                count--;
            else
                count++;
        }
        return count <= 1;
    }
    public void swap(char[] s, int i, int j) {
        char temp = s[i];
        s[i] = s[j];
        s[j] = temp;
    }
    void permute(char[] s, int l, char ch) {
        if (l == s.length) {
            set.add(new String(s) + (ch == 0 ? "" : ch) + new StringBuffer(new String(s)).reverse());
        } else {
            for (int i = l; i < s.length; i++) {
                if (s[l] != s[i] || l == i) {
                    swap(s, l, i);
                    permute(s, l + 1, ch);
                    swap(s, l, i);
                }
            }
        }
    }
}

leetcode270:
给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的数值。
注意：
给定的目标值 target 是一个浮点数
题目保证在该二叉搜索树中只会存在一个最接近目标值的数
示例：
输入: root = [4,2,5,1,3]，目标值 target = 3.714286

4

/
2 5
/
1 3

输出: 4
class Solution {
public int closestValue(TreeNode root, double target) {
double minlength=Double.MAX_VALUE;
int result=0;
while(root!=null){
result=minlength>Math.abs(target-root.val)?root.val:result;
minlength=Math.min(minlength,Math.abs(target-root.val));
if(root.val>target)root=root.left;
else if(root.val else return root.val;
}
return result;
}
}

leetcode:658
给定一个排序好的数组，两个整数 k 和 x，从数组中找到最靠近 x（两数之差最小）的 k 个数。返回的结果必须要是按升序排好的。如果有两个数与 x 的差值一样，优先选择数值较小的那个数。
示例 1:
输入: [1,2,3,4,5], k=4, x=3
输出: [1,2,3,4]
示例 2:
输入: [1,2,3,4,5], k=4, x=-1
输出: [1,2,3,4]

class Solution {
    public List findClosestElements(int[] arr, int k, int x) {
        LinkedList list=new LinkedList<>();
        int low=0,high=arr.length-1;
        while((high-low+1)>k){
            if(Math.abs(arr[low]-x)>Math.abs(arr[high]-x))low++;
            else high--;
        }
        while(low<=high)list.add(arr[low++]);
        return list;
    }
}

leetcode 272：
给定一个不为空的二叉搜索树和一个目标值 target，请在该二叉搜索树中找到最接近目标值 target 的 k 个值。:
注意：
给定的目标值 target 是一个浮点数
你可以默认 k 值永远是有效的，即 k ≤ 总结点数
题目保证该二叉搜索树中只会存在一种 k 个值集合最接近目标值
示例：
输入: root = [4,2,5,1,3]，目标值 = 3.714286，且 k = 2
4
/
2 5
/
1 3

输出: [4,3]
272
解析：二叉搜索树中序遍历即转化为LeetCode658题。但是如何记录这个数组？
方法一：用一个很大很大的数组，空间复杂度太高
方法二：堆需要调试

class Solution implements Comparator {
    double target;
    PriorityQueue queue=new PriorityQueue<>();
    public List closestKValues(TreeNode root, double target, int k) {
        this.target=target;
        Listlist=new ArrayList(queue);
        return list;
    }
    public void getValue(TreeNode root, double target, int k){
        if(root!=null){
            getValue(root.left,target, k);
            if(queue.size()k)queue.remove();
            getValue(root.right, target, k);
        }
    }
    public int compare(Integer a,Integer b){
       if(Math.abs(a-target)>Math.abs(b-target))return 1;return -1;
    }
}

方法三：非连续的滑动窗口

public class Solution {
    public List closestKValues(TreeNode root, double target, int k) {
        LinkedList res = new LinkedList<>();
        inOrder(root, target, k, res);
        return res;
    }
    private void inOrder(TreeNode root, double target, int k, LinkedList res) {
        if(root == null) {
            return;
        }
        inOrder(root.left, target, k, res);
        if(res.size() == k) {
            if(Math.abs(res.get(0) - target) >= Math.abs(root.val - target)) {
                res.removeFirst();
                res.add(root.val);
            } else {
                return;
            }
        } else {
            res.add(root.val);
        }
        inOrder(root.right, target, k, res);
    }
}

leetcode274:
给定一位研究者论文被引用次数的数组（被引用次数是非负整数）。编写一个方法，计算出研究者的 h 指数。
h 指数的定义: “h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （N 篇论文中）至多有 h 篇论文分别被引用了至少 h 次。（其余的 N - h 篇论文每篇被引用次数不多于 h 次。）”
示例:
输入: citations = [3,0,6,1,5]
输出: 3
解释: 给定数组表示研究者总共有 5 篇论文，每篇论文相应的被引用了 3, 0, 6, 1, 5 次。
由于研究者有 3 篇论文每篇至少被引用了 3 次，其余两篇论文每篇被引用不多于 3 次，所以她的 h 指数是 3。
方法一：利用下标的关系

import java.util.*;
class Solution {
    public int hIndex(int[] citations) {
        if(citations.length==0)return 0;
        Arrays.sort(citations);
        int index=0,i=1;
        while(citations.length-i>=0&&citations[citations.length-i]>=i){
            index++;i++;
        }
        return index;
    }
}

方法二：计数排序的变形对所有超过n的，都转化为n

public class Solution {
    public int hIndex(int[] citations) {
        int n = citations.length;
        int[] papers = new int[n + 1];
        // 计数
        for (int c: citations)
            papers[Math.min(n, c)]++;
        // 找出最大的 k
        int k = n;
        for (int s = papers[n]; k > s; s += papers[k])
            k--;
        return k;
    }
}

leetcode275
给定一位研究者论文被引用次数的数组（被引用次数是非负整数），数组已经按照升序排列。编写一个方法，计算出研究者的 h 指数。
h 指数的定义: “h 代表“高引用次数”（high citations），一名科研人员的 h 指数是指他（她）的 （N 篇论文中）至多有 h 篇论文分别被引用了至少 h 次。（其余的 N - h 篇论文每篇被引用次数不多于 h 次。）"
解析：二分查找

class Solution {
    public int hIndex(int[] citations) {
        int low=0,high=citations.length-1,mid=0;
        int index=0;
        int length=citations.length;
        while(low<=high){
            mid=(low+high)/2;
            if(citations[mid]>length-mid){
                if(mid==0||citations[mid-1]length-mid-1)return length-1-mid;
                else low=mid+1;
            }
            else {
                return length-mid;
            }
        }
        return 0;
    }
}