目录

一.做题总结

1.约瑟夫问题

2.最近请求次数

4.选择题订正

二.最长字符串

三.最长数组问题

---

一.做题总结

1.约瑟夫问题

我的思路就是先遍历按队员编号添加按顺序初始化每个人的编号.

就建立循环,终止条件就是大小为1

进入每次叫号的循环.让编号不为1的全部移出去

因为题目要求上次叫的从第二次循环的额开始,所以就把最后一个移到前面来

这道题不做不知道一做吓一跳

首先我刚开始用的接口是Queue的.然后发现removeLast根本没有

然后我就改成双向队列.deque的接口就发现一直进入死循环

想来想去可能就是在remove函数出现问题

去idea查了下deque底层方法.就发现根本没有这个方法

他只会默认删除第一个.是不带参数的

所以我们只能用LinkedList自己来引用对象

import java.util.*;

public class Joseph {
    public int getResult(int n) {
        // write code here
        Deque<Integer> queue = new LinkedList<>();
        int count = 2;
        int i = 1;
        while (i <= n) {
            queue.add(i);
            i++;
        }//初始化完成
        while (queue.size() != 1) {
            int cur = 0;
            i = 0;
            while (queue.size() > 1 && i < queue.size()) {
                cur = (cur + 1) % count;
                if (cur != 1) {
                    queue.remove(i);
                } else {
                    i++;
                }
            }
            count++;
            int ret = queue.removeLast();
            queue.addFirst(ret);
        }
        return queue.pop();


    }
}

2.最近请求次数

其实这道题并不是很难.我刚开始想到用队列来做,然后一直无法编译通过

逻辑也没错.我检查了一下错误用用例发现了数据特别大,

我检查了一下,发现很有可能是

因为这个数据是往后递增的,所以只要找到小于n的,就不需要往后再找了

但是我还一直往后加,找,所以我就改了一下,只要找到就跳出循环

官方解答用的是单项向队列,直接弹出

感觉更简单一些

4.选择题订正

子类继承父类,需要先帮助父类构造方法,此题没有写,代表就是默认的

但是这里的name是private修饰的,只能在类内进行访问

子类帮助父类构造,要在构造方法写上super();

catch是不能省略的

面向对象的三大特性包括：封装，继承，多态

SQL语言又称为结构化查询语言

A选项,不能直接调用,要用super,方法

B选项类方法就是静态方法,不能直接调用,要用类名调用.除非是本类调用

二.最长字符串

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
        char[] arr=str.toCharArray();
        String cur="";
        String q="";
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]>='0'&&arr[i]<='9'){
                StringBuilder sb=new StringBuilder();
                while(i < arr.length&&arr[i]>='0'&&arr[i]<='9'){
                    sb.append(arr[i]);
                    i++;
                }
                cur=sb.toString();
                if(cur.length()>q.length()){
                    q=cur;
                }
            }
        }
        System.out.println(q);
    }
}

其他的做法

字符串不能直接拼接字符,

加个双引号

就直接改变引用指向的对象

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String str=sc.nextLine();
       // char[] arr=str.toCharArray();
        String cur="";
        String q="";
        for (int i = 0; i < str.length(); i++) {
            char ch=str.charAt(i);
            if(ch>='0'&&ch<='9'){
               cur=cur+ch+"";
                }else{
                if(cur.length()>q.length()){
                    q=cur;
                }
                cur="";
               }
               
            }
        if(cur.length()>q.length()){
                    q=cur;
                }
          System.out.println(q);
        }
      
 }

三.最长数组问题

我先想到就是暴力解法,遍历每个数组元素,然后让他遍历往后的每一个

只要有相同的就++.只要超过数组长度一半就返回

但是最后一组测试用例出现了问题

应该是有好几个都超过了数组长度,但是需要找最长的那一个

所以我定义两个变量,记录每次超过数组长度的元素的次数和大小,

如果下次还超过 就替换

最后返回11.25

import java.util.*;
public class Solution {
    public int MoreThanHalfNum_Solution (int[] numbers) {
// write code here
      int n=numbers.length;
      if(n==1){
          return numbers[0];
      }
      int x=0;int y=0;
        for (int i = 0 ; i < n; i++) {
            int j = numbers[i];
                int a = 1;
            for (int t = i + 1; t < n; t++) {
                if ( j == numbers[t]) {
                    a++;
                }
                if (a >= n/2) {
                   if(a>x){
                       x=a;y=j;
                   }
                }
            }
        }
        return y;
    }
}