每日一题8-n个数最小的k个-删数

最新推荐文章于 2024-07-25 14:31:34 发布

xiong1234717

最新推荐文章于 2024-07-25 14:31:34 发布

阅读量83

点赞数

分类专栏：每日一题文章标签：队列 java

本文链接：https://blog.csdn.net/weixin_43793613/article/details/119795597

版权

每日一题专栏收录该内容

12 篇文章 0 订阅

订阅专栏

java中关于内存回收的正确说法是（）
A 程序员必须创建一个线程来释放内存
B 内存回收程序负责释放无用内存
C 内存回收程序允许程序员直接释放内存
D 内存回收程序可以在指定的时间释放内存对象
答案：【B】
【解析】解析：A：垃圾回收程序是一般是在堆上分配空间不够的时候会自己进行一次GC，程序员不需要也不能主动释放内存。
B：Java的内存释放由垃圾回收程序来进行释放
C：在Java里，内存的释放由垃圾回收程序进行管理，程序员不能直接进行释放。
D：程序员可以调用System.gc()运行垃圾回收器，但是不能指定时间。
以下说法错误的是（）
A 数组是一个对象
B 数组不是一种原生类
C 数组的大小可以任意改变
D 在Java中，数组存储在堆中连续内存空间里
【答案】：C
【解析】：Java不允许修改数组长度，这也是Java安全性的体现之一。数组长度必须在编译时确定。数组是一种对象，不是原生类，原生类有8种， int double boolean float byte short long char
Test.main() 函数执行后的输出是（）

public class Test {
public static void main(String [] args){
System.out.println(new B().getValue());
}
static class A{
protected int value;
public A(int v) {
setValue(v);
}
public void setValue(int value){
this.value = value;
}
public int getValue(){
try{
value++;
return value;
} catch(Exception e){
System.out.println(e.toString());
} finally {
this.setValue(value);
System.out.println(value);
}
return value;
}
}
static class B extends A{
public B() {
super(5);
setValue(getValue() - 3);
}
public void setValue(int value){
super.setValue(2 * value);
}
}
}

A 11 17 34
B 22 74 74
C 6 7 7
D 22 34 17
【答案】：D
【解析】：super()函数指的是调用父类的构造方法
① new B()执行B的构造函数
第一行是super(5);此时执行的是A的构造函数，A的构造函数调用的是setValue()方法，由于B重写了A的这个方法，所以，执行的是B的 setValue()方法。即传入的参数是25=10。此时，因为super，所以调用的是父类的 setValue()方法，即value=10。第一行执行完毕。
第二行是 setValue(getValue()-3);B没有getValue()方法，故执行父类的此方法，try返回的是value=10+1=11，保存在临时栈中，finally中调用this的方法，这个this指的是B的对象，又重写，故就是B的 setValue()方法。value=211=22，然后打印下来。接下来参数 getValue()-3=11-3=8。传入B的 setValue()方法，此时value=28=16。至此，new B()执行结束
② new B(). getValue()。B没有 getValue()，故执行A的 getValue()。try返回16+1=17，保存到临时栈中，finally调用B的 setValue()方法value=172=34，第二个数字打印了。最后主函数打印返回值，也就是打印try保存到临时栈中的17。

JUnit主要用来完成什么（）
A 发送HTTP请求
B 建立TCP连接
C 集成测试
D 单元测试
【答案】：D
【解析】：JUnit是一个Java语言的单元测试框架，有程序员自测，就是所谓的白盒测试，主要四个方向（1）用于测试期望结果的断言（Assertion）（2）用于共享共同测试数据的测试工具（3）用于方便的组织和运行测试的测试套件（4）图形和文本的测试运行器（unit单元的意思）
【找出n个数里最小的k个】
输入描述：
每个测试输入包含空格分割的n+1个整数，最后一个整数为k值,n 不超过100。
输出描述：
输出n个整数里最小的k个数。升序输出
解法1： TOPK问题用堆解建立一个大小为k的大堆

public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        String str = scan.nextLine();
        String[] tmp = str.split(" ");
        int[] arr = new int[tmp.length-1];
        int j = 0;
        for (; j < tmp.length-1; j++) {
            arr[j] = Integer.parseInt(tmp[j]);
        }
        int k = Integer.parseInt(tmp[tmp.length-1]);
        PriorityQueue<Integer> qu = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }
        });
        for (int i = 0; i < k; i++) {
            qu.offer(arr[i]);
        }
        for (int i = k; i < arr.length; i++) {
            if (qu.peek() >arr[i]){
                qu.poll();
                qu.offer(arr[i]);
            }
        }
        int[] ret = new int[k];
        for (int i = 0; i<k;i++) {
            ret[i] = qu.poll();
        }
        for (int i = k-1; i >=0 ; i--) {
            System.out.print(ret[i]+" ");
        }

    }
}

解法2：暴力解法
先把输入的字符串用空格分割，后存到数组中，注意最后一个是K，然后用工具类给数组排序，最后打印前K个元素即可

import java.util.*;
public class Main{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while (in.hasNext()) {
            String tmp = in.nextLine();
            String[] str = tmp.split(" ");
            int[] arr = new int[str.length - 1];
            int k = 0;
            for (int i = 0; i < str.length; i++) {
                if (i < str.length - 1) {
                    arr[i] = Integer.parseInt(str[i]);
                } else {
                    k = Integer.parseInt(str[i]);
                }
            }
            if (k <= 0 || k > str.length - 1) {
                return;
            }
            Arrays.sort(arr);
            for (int j = 0; j < k; j++) {
                if (j == k - 1) {
                    System.out.print(arr[j]);
                } else {
                    System.out.print(arr[j] + " ");
                }
            }
        }
    }
}

解法3：快排

public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String s1 = scan.nextLine();
        String[] s2 = s1.split(" ");
        int[] arr = new int[s2.length-1];
        for (int i = 0; i <s2.length-1 ; i++) {
            arr[i] = Integer.parseInt(s2[i]);
        }
        int k = Integer.parseInt(s2[s2.length-1]);
        int start = 0;
        int end = arr.length-1;
        int index = pivot(start,end,arr);
        //快排
        while (index != k){
            if (index > k){
                end = index-1;
                index = pivot(start,end,arr);
            }else {
                start = index+1;
                index = pivot(start,end,arr);
            }
        }
        Arrays.sort(arr,0,k);
        for (int i = 0; i < k; i++) {
            System.out.print(arr[i]+" ");
        }
    }

    public static  int pivot(int start,int end, int[] arr){
        int tmp = arr[start];
        while (start<end){
            while (start<end && arr[end]>=tmp){
                end--;
            }
            arr[start] =arr[end];
            while (start<end && arr[start] <=tmp){
                start++;
            }
            arr[end] = arr[start];
        }
        arr[start] = tmp;
        return start;
    }

有一个数组a[N]顺序存放0~N-1，要求每隔两个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。以8个数(N=7)为例:｛0，1，2，3，4，5，6，7｝，0->1->2(删除)->3->4->5(删除)->6->7->0(删除),如此循环直到最后一个数被删除。
输入描述：
每组数据为一行一个整数n(小于等于1000)，为数组成员数,如果大于1000，则对a[999]进行计算。
输出描述：
一行输出最后一个被删掉的数的原始下标位置。
【解析】：可以弄两个队列，然后一个计数的count，等count==2时只出队不入队。

 public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        while(scan.hasNext()){ 
        int num = scan.nextInt();
        Queue<Integer> qu1 = new LinkedList<>();
        Queue<Integer> qu2 = new LinkedList<>();
        int count = 0;
        for (int i = 0; i <num ; i++) {
            qu1.add(i);
        }
        while (qu1.size()+ qu2.size() !=1){
            while (!qu1.isEmpty()){
                if (count==2){
                    //删数
                    qu1.poll();
                    count=0;
                }else {
                    qu2.add(qu1.poll());
                    count++;
                }
            }
            while (!qu2.isEmpty()){
                if (count ==2){
                    //删数
                    qu2.poll();
                    count=0;
                }else {
                    qu1.add(qu2.poll());
                    count++;
                }
            }
        }
        if (qu1.size() == 1){
            System.out.println(qu1.poll());
        }
        if (qu2.size() == 1){
            System.out.println(qu2.poll());
        }
        }
    }

xiong1234717

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
每日一题8-n个数最小的k个-删数

java中关于内存回收的正确说法是（）A 程序员必须创建一个线程来释放内存B 内存回收程序负责释放无用内存C 内存回收程序允许程序员直接释放内存D 内存回收程序可以在指定的时间释放内存对象答案：【B】【解析】解析：A：垃圾回收程序是一般是在堆上分配空间不够的时候会自己进行一次GC，程序员不需要也不能主动释放内存。B：Java的内存释放由垃圾回收程序来进行释放C：在Java里，内存的释放由垃圾回收程序进行管理，程序员不能直接进行释放。D：程序员可以调用System.gc()运行垃圾回收器，.
复制链接

扫一扫

专栏目录