长度为500的队列,每次去掉位置为3的倍数的元素,求最后去掉的元素

最新推荐文章于 2025-06-01 10:00:00 发布

原创最新推荐文章于 2025-06-01 10:00:00 发布

· 418 阅读

0 ·

版权

文章标签：

#java

其他专栏收录该内容

4 篇文章

订阅专栏

本文探讨了一种特殊的算法问题，即从一个包含500个元素的列表中，每次去除位于位置为3的倍数的元素，直到列表剩余4个元素为止。文章提供了两种解决方案，一种使用ArrayList迭代，另一种利用迭代器优化算法，显著降低了时间和空间复杂度。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述
一开始以为是老问题,每次留下位置为:3的倍数的人,问最后一个留下的是几
那很简单,就是求n范围内,3的n次方的max值

仔细一看发现不是

解法①

		//自己写个PSVM
		
        /*队列去3问题*/
        ArrayList<Integer> originList = new ArrayList<>();
        /*获取500个元素的列表*/
        for (int i = 1; i < 501; i++) {
            originList.add(i);
        }
        checkThird(originList);

        //调用的check方法    
        private ArrayList<Integer> checkThird(ArrayList<Integer> originList) {
        /*建立一个保留第1.第2位元素的列表 */
        ArrayList<Integer> removedThirdList = new ArrayList<>();
        for (int i = 0; i < originList.size(); i++) {
            /*当位数+1有余，则添加进保留列表*/
            if ((i+1) %3 != 0) {
                removedThirdList.add(originList.get(i));
            }
        }
        /*当保留列表长度位4时，则打印最后的列表内容*/
        if (removedThirdList.size() == 4) {
            System.out.println(removedThirdList);
            return removedThirdList;
        }else {
            /*否，则继续迭代*/
            System.out.println(removedThirdList);
            return checkThird(removedThirdList);
        }
    }
    }

其实算法并不优
因为不会用迭代器,于是查了下api

解法②

    private ArrayList<Integer> checkThirdV2(ArrayList<Integer> originList) {
   		//获取迭代器
        Iterator<Integer> iterator = originList.iterator();
        //标记一个flag,初始位1
        int i = 1;
        //进行遍历
        while (iterator.hasNext()){
        	//当有next元素时,指针后移
            iterator.next();
            //当flag除3无余,则删除该元素
            if ((i%3) == 0) {
                iterator.remove();
            }
            i++;
        }
        //当删减后的列表长度为4,则得到想要的结果列表
        if (originList.size()==4){
            System.out.println(originList);
            return originList;
            //否,则继续迭代
        }else return checkThirdV2(originList);

    }

时间复杂度减少到o的n
空间减少到n
迭代器这个时候还是挺好用的.