4月30日算法刷题

import javax.xml.stream.events.Characters;
import java.util.*;

public class test_04_27 {

    //KMP算法

    //替换空格
    public static void test1(String s){
        StringBuilder stringBuilder = new StringBuilder();
        for (int i=0;i<s.length();i++){
            if (s.charAt(i)!=' '){
                stringBuilder.append(s.charAt(i));
            }else{
                stringBuilder.append("%20");
            }
        }
        System.out.println(stringBuilder.toString());
    }
    //最长公共前缀
    public static void test2(String[] strs){
        int min = strs[0].length();
        for (int i=1;i<strs.length;i++){
            min = Math.min(min, strs[i].length());
        }
        String res = "";
        for (int i=0;i<min;i++){
            boolean flag = true;
            for (int j=0;j<strs.length-1;j++){
                if (strs[j].charAt(i)!=strs[j+1].charAt(i)){
                    flag = false;
                    break;
                }
            }
            if (flag){
                res += strs[0].charAt(i);
            }else{
                break;
            }
        }
        System.out.println(res);
    }

    //最长回文串
    public static void test3(String s){
        TreeMap<Character, Integer> hashMap = new TreeMap<>();
        for (int i=0;i<s.length();i++){
            hashMap.put(s.charAt(i),hashMap.getOrDefault(s.charAt(i),0)+1);
        }
        Collection<Integer> values = hashMap.values();
        Integer[] integers = values.toArray(new Integer[values.size()]);

        int res = 0;
        int x = -1;
        for (int i=0;i<values.size();i++){
            res += integers[i]/2*2;
            if ((integers[i]&1)==1&&integers[i]>x){
                x=integers[i];
            }
        }
        if (x!=-1){
            res += x;
        }

        System.out.println(res);
    }

    //验证回文串
    public static boolean test4(String s){
        int i=0;
        int j=s.length()-1;
        while (i<j){
            while (i<j&&!Character.isLetter(s.charAt(i))&&!Character.isDigit(s.charAt(i))){
                i++;
            }
            while (i<j&&!Character.isLetter(s.charAt(j))&&!Character.isDigit(s.charAt(j))){
                j--;
            }
            if ((Character.isDigit(s.charAt(i))&&Character.isDigit(s.charAt(j))
                    &&(Character.isDigit(s.charAt(i))==Character.isDigit(s.charAt(j))))
                    || Character.toLowerCase(s.charAt(i))==Character.toLowerCase(s.charAt(j))){
                i++;
                j--;
            }else{
                return false;
            }
        }
        return true;
    }
    //找出最长回文子串 babad
    public static void test5(String s){
        int n = s.length();
        boolean[][] flag = new boolean[n][n];
        String res = "";
        for (int k=0;k<n;k++){
            int i=0;
            int j=i+k;
            while (j<n){
                if (k==0){
                    flag[i][j]=true;
                }else if (k==1){
                    flag[i][j]= s.charAt(i) == s.charAt(j);
                }else{
                    if (s.charAt(i)==s.charAt(j)){
                        flag[i][j]=flag[i+1][j-1];
                    }else{
                        flag[i][j]=false;
                    }
                }
                if (flag[i][j]&&j-i+1>res.length()){
                    res=s.substring(i,j+1);
                }
                i++;
                j++;
            }
        }
        System.out.println(res);
    }
    //最长回文子序列
    //   b a c a d b
    // b
    // a
    // c
    // b
    public static void test6(String s){
        int n = s.length();
        int[][] dp = new int[n][n];
        int res = 1;
        for (int k=0;k<n;k++){
            int i=0;
            int j=i+k;
            while (j<n){
                if (k==0){
                    dp[i][j]=1;
                }else if (k==1){
                    if (s.charAt(i)==s.charAt(j)){
                        dp[i][j]=2;
                    }else{
                        dp[i][j]=1;
                    }
                }else{
                    if (s.charAt(i)==s.charAt(j)){
                        dp[i][j]=dp[i+1][j-1]+2;
                    }else{
                        dp[i][j]=Math.max(dp[i+1][j],dp[i][j-1]);
                    }
                }
                res = Math.max(dp[i][j],res);
                i++;
                j++;
            }
        }
        System.out.println(res);
    }
    //字符串转为整数 "1233444322"
    public static void test7(String s){
        int k=1;
        int res = 0;
        //去除符号位
        int flag = 0;
        if (s.charAt(0)=='+'){
            flag=1;
        }else if (s.charAt(0)=='-'){
            flag=2;
        }
        int end = flag>0?1:0;
        for (int i=s.length()-1;i>=end;i--){
            if (!Character.isDigit(s.charAt(i))){
                System.out.println("不符合");
                return;
            }
            res += (s.charAt(i)-48)*k;
            k=k*10;
        }
        if (flag==2){
            System.out.println(-1*res);
        }else{
            System.out.println(res);
        }
    }
    //最长有效括号
    //)()())
    public static void test8(String s){
        int n = s.length();
        int[] dp = new int[n];
        for (int i=0;i<n;i++){
            if (s.charAt(i)=='('){
                dp[i]=0;
            }else{
                if (i==0){
                    continue;
                }
                if (s.charAt(i-1)==')'){
                    if (i-dp[i-1]-1>=0&&(s.charAt(i-dp[i-1]-1)=='(')){
                        if (i-dp[i-1]-2>=0){
                            dp[i]=dp[i-1]+2+dp[i-dp[i-1]-2];
                        }else{
                            dp[i]=dp[i-1]+2;
                        }
                    }
                }else{
                    if (i-2>=0){
                        dp[i]=dp[i-2]+2;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(dp));
    }


    //给出一个合法的
    public static void test9(String s){
        int max=0;
        int count=0;
        for (int i=0;i<s.length();i++){
            if (s.charAt(i)=='('){
                count++;
            }else{
                count--;
            }
            max = Math.max(max,count);
        }
        System.out.println(max);
    }

    static class TreeNode{
        int data;
        TreeNode next;
        public TreeNode(int data){
            this.data = data;
        }
    }
    //两数相加
    public static TreeNode test10(TreeNode root1,TreeNode root2){
        int k=0;
        TreeNode pre=root1;
        TreeNode p=null;
        TreeNode q=root2;
        while (root1!=null&&root2!=null){
            int res = root1.data+root2.data +k;
            root1.data = res%10;
            k = res/10;
            p=root1;
            root1=root1.next;
            root2=root2.next;
        }
        if (p==null){
            return q;
        }
        while (root2!=null){
            int res = root2.data+k;
            k = res/10;
            p.next=new TreeNode(res%10);
            root2=root2.next;
        }
        return pre;
    }

    //翻转链表
    public static TreeNode test11(TreeNode root){
        TreeNode pre = null;
        TreeNode p = root;
        TreeNode pp = root.next;
        while (pp!=null){
            p.next=pre;
            pre=p;
            p=pp;
            pp=pp.next;
        }
        p.next=pre;
        return p;
    }

    public static TreeNode test12(TreeNode root){
        if (root.next==null){
            return root;
        }
        TreeNode newHead = test12(root.next);
        root.next.next=root;
        root.next=null;
        return newHead;
    }

    //链表中倒数第k个节点
    // 1 2 3 4 5
    public static void test13(TreeNode root,int k){
        TreeNode p = root;
        TreeNode q = root;
        while (q!=null&&k-->0){
            q=q.next;
        }
        //判断
        if (q==null&&k>0){
            System.out.println("找不到");
            return;
        }
        while (q!=null){
            p=p.next;
            q=q.next;
        }
        System.out.println(p.data);
    }

    //删除链表中倒数第k个节点
    public static TreeNode test14(TreeNode root,int k){
        TreeNode p = root;
        TreeNode q = root;
        while (q!=null&&k-->0){
            q=q.next;
        }
        //判断
        if (q==null&&k>0){
            System.out.println("找不到");
            return null;
        }
        TreeNode pre = null;
        while (q!=null){
            pre = p;
            p=p.next;
            q=q.next;
        }
        if (pre==null){
            root = root.next;

        }else{
            pre.next=p.next;
        }
        return root;
    }
    //合并两个排序的链表
    //1
    //2 3
    public static TreeNode test15(TreeNode root1, TreeNode root2){
        TreeNode dump = new TreeNode(-1);
        TreeNode p = dump;
        while (root1!=null&&root2!=null){
            if (root1.data<root2.data){
                p.next=root1;
                root1 = root1.next;
                p=p.next;
            }else{
                p.next=root2;
                root2 = root2.next;
                p=p.next;
            }
        }
        if (root1!=null){
            p.next=root1;
        }
        if (root2!=null){
            p.next=root2;
        }
        return dump.next;
    }

    //颜色分类
    public static void sortColors(int[] nums) {
        int left = 0;
        int right = nums.length-1;
        int mid=0;
        while (mid<=right){
            if (nums[mid]==0){
                int temp = nums[left];
                nums[left]=nums[mid];
                nums[mid] = temp;
                left++;
                mid++;
            }else if (nums[mid]==2){
                int temp = nums[right];
                nums[right]=nums[mid];
                nums[mid] = temp;
                right--;
            }else{
                mid++;
            }
        }
    }

    //1 1 1 2 2
    //在排序数组中查找元素第一个和最后一个
    public static int[] searchRange(int[] nums, int target) {
        int i=0;
        int[] res = new int[2];
        Arrays.fill(res,-1);
        while (i<nums.length){
            if (i>0&&nums[i]==nums[i-1]){
                if (nums[i]==target){
                    res[1]=i;
                }
                i++;
            }else{
                if (target==nums[i]){
                    res[0]=i;
                    res[1]=i;
                }
                i++;
            }
        }
        return res;
    }
    public static void main(String[] args) {
        int[] ints = searchRange(new int[]{5,7,7,7,8,8,10}, 7);
        System.out.println(Arrays.toString(ints));
    }
}