算法错题

1、给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

public class test {
    public int singleNumber(int[] nums){
        int num = 0;
        for(int i =0; i<nums.length; i++){
            num = num^nums[i];
        }
        return num;
    }
    public static void main(String[] args) {
      int[] num = {2,2,1};
      test t = new test();
      System.out.println(t.singleNumber(num));

    }
}

2、给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序 ## 数组。 说明: 初始化 nums1 和 nums2 的元素数量分别为 m 和 n。 你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。 示例: 输入: nums1 = [1,2,3,0,0,0], m = 3 nums2 = [2,5,6], n = 3 输出: [1,2,2,3,5,6]

public class test {
    public void merge(int[] nums1, int m, int[] nums2, int n){
        int i = m - 1;
        int j = n - 1;
        int writeindex = m + n - 1;
        while(i >=0 && j >=0) {
            nums1[writeindex--] = nums1[i] > nums2[j] ? nums1[i--] : nums2[j--];
        }
        while(j>=0){
            nums1[writeindex--] = nums2[j--];
        }
        System.out.print("[");
        for(int k = 0; k < nums1.length; k ++){
            System.out.print(nums1[k]);
            if(k < nums1.length-1){
                System.out.print(",");
            }
        }
        System.out.println("]");
    }
    public static void main(String[] args) {
        int[] nums1 ={1,2,3,0,0,0};
        int[] nums2 = {2,5,6};
        int m = 3;
        int n = 3;
        test t = new test();
        t.merge(nums1,m,nums2,n);
    }
}

3、有2个鸡蛋，从100层楼上往下扔，以此来测试鸡蛋的硬度。比如鸡蛋在第9层没有摔碎，在第10层摔碎了，那么鸡蛋不会摔碎的临界点就是9层。 问：如何用最少的尝试次数，测试出鸡蛋不会摔碎的临界点？ 进阶版：你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N 共有 N 层楼的建筑。 每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。 你知道存在楼层 F ，满足 0 <= F <= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。 每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 <= X <= N）。 你的目标是确切地知道 F 的值是多少。 无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？

public class solution {
    public int drop(int n){
        int a = 1;
        int b = 1;
        int c = -2 * n;
        double[] res = equation(a,b,c);
        return (int) Math.ceil(res[0]);
    }
    double[] equation(int a, int b, int c){
        double delta = b * b - 4 * a * c;
        double[] res = new double[1];
        if(delta < 0){
            return new double[0];
        }else if(delta > 0){
            double tmp1,tmp2;
            tmp1 = ((-b + Math.sqrt(delta))/(2 * a));
            tmp2 = ((-b - Math.sqrt(delta))/(2 * a));
            res[0] = Math.max(tmp1 , tmp2);
        }else{
            res = new double[]{-b/(2 * a)};
        }
        return res;
    }
    public int drop_dp(int n, int k) {
        int[][] dp = new int[n+1][k+1];//注意，这里初始化为0

        //边界
        for(int i=1; i<=n; i++) {
            dp[i][1] = i;
        }
        for(int j=1; j<=k; j++) {
            dp[1][j] = 1;
        }

        for(int i=1; i<=n; i++) {
            for(int j=1; j<=k; j++) {
                for(int t=1; t<i; t++) {
                    if(dp[i][j]==0) {//如果不分类，很多原始为0的取最小值就还为0
                        dp[i][j] = Math.max(dp[t - 1][j - 1], dp[i - t][j]) + 1;
                    }
                    else {
                        dp[i][j] = Math.min(Math.max(dp[t - 1][j - 1], dp[i - t][j]) + 1,dp[i][j]);
                    }
                }
            }
        }

        return dp[n][k];
    }


    public static void main(String[] args) {
        solution s = new solution();
        int res = s.drop(100);
        System.out.println(res);
        int n = s.drop_dp(10000,10);
        System.out.println(n);
    }
}

4、给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。 说明：本题中，我们将空字符串定义为有效的回文串。 示例 1: 输入: “A man, a plan, a canal: Panama” 输出: true 示例 2: 输入: “race a car” 输出: false

import java.util.Scanner;

public class solution {
    public boolean ishuishu(String text){

        char[] s1 = new char[text.length()];
        char[] s2 = new char[text.length()];
        boolean flag = true;
        for(int i =0; i <s1.length; i++){
            s1[i] = text.toCharArray()[i];
            s2[i] = text.toCharArray()[s2.length-i-1];
            if(s1[i] != s2[i]){
                flag = false;
            }
        }
        return flag;

    }

    public static String filter(String s){
        StringBuffer strBuf = new StringBuffer();
        for(int i =0; i <s.length(); i ++){
            if(Character.isLetterOrDigit(s.charAt(i)))//取出字符与数字部分
                strBuf.append(s.charAt(i));
        }
        return strBuf.toString();
    }
    public static void main(String[] args) {
        solution solution = new solution();
        Scanner in = new Scanner(System.in);
        System.out.println("Please enter a string");
        String s = in.nextLine();
        s =s.toLowerCase();//转化为小写
        String str = filter(s);
        System.out.println(solution.ishuishu(str));

    }
}

5、给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

示例 1：

输入: “babad”
输出: “bab”
注意: “aba” 也是一个有效答案。
示例 2：

输入: “cbbd”
输出: “bb”
（使用中心扩展法，直观的想法测试超时）

public class test {
    public String longestPalindroms(String s){
        if(s == null || s.length() < 1)
            return "";
        int start = 0;
        int end = 0;
        for(int i = 0; i < s.length(); i ++){
            int len1 = expandAroundCenter(s,i,i);//回文字符是奇数
            int len2 = expandAroundCenter(s,i,i+1);//回文字符是偶数
            int len = Math.max(len1,len2);
            if(len > (end - start)){
                start = i - (len - 1)/2;
                end = i + len / 2;
            }
        }
        return s.substring(start,end+1);
    }
    //比较左右两个字符是否相同，一直向外扩
    private int expandAroundCenter(String s, int left, int right){
        int L = left, R = right;
        while(L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)){
            L--;
            R++;
        }
        return R - L -1;
    }
    public static void main(String[] args) {
        String s = "cdcabacb";
        test t = new test();
        System.out.println(t.longestPalindroms(s));

    }
}

6、给出一个链表，每 k 个节点一组进行翻转，并返回翻转后的链表。

k 是一个正整数，它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍，那么将最后剩余节点保持原有顺序。

示例 :

给定这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

        public class ListNode {
            int val;
            ListNode next;
            public ListNode(int x){
                val = x;
            }
        }
    

public class Solution {
    public ListNode reverseKGroup(ListNode head, int k){
       ListNode prev = null;
       ListNode cur = head;
       ListNode next = null;
       ListNode check = head;
       int canProced = 0;
       int count = 0;
       //判断长度是否够k
       while(canProced < k && check !=null){
           check = check.next;
           canProced ++;
       }
       //如果长度够k则进行翻转
       if(canProced == k){
           while(count < k && cur != null){
               next = cur.next;
               cur.next = prev;
               prev = cur;
               cur = next;
               count++;
           }
           if(next != null){
               head.next = reverseKGroup(next,k);
           }
           int ss = prev.val;
           return prev;
       }//如果长度不够k则直接输出
       else{
           return head;
       }
    }
    //建链表
    public static ListNode build(int[] a){
        ListNode first = null,last = null,newNode;
        for(int i =0; i < a.length; i ++){
            newNode = new ListNode(a[i]);
            if(first==null || last==null){
                first = newNode;
                last = newNode;
            }else{
                last.next = newNode;
                last = newNode;
            }
        }
        return first;
    }

    public static void main(String[] args) {
        int[] a = new int[]{1,2,3,4,5};
        int k =2;
        Solution s = new Solution();
        ListNode listNode = build(a);
        ListNode listNode1 = s.reverseKGroup(listNode,k);
        while(listNode1!=null){
            System.out.println(listNode1.val);
            listNode1 = listNode1.next;
        }
    }
}