【进阶篇-Day9：JAVA中单列集合Collection、List、ArrayList、LinkedList的介绍】

news2024/9/24 9:21:57

目录

  • 1、集合的介绍
    • 1.1 概念
    • 1.2 集合的分类
  • 2、单列集合：Collection
    • 2.1 Collection的使用
    • 2.2 集合的通用遍历方式
      • `2.2.1 迭代器遍历：`
        • （1）例子：
        • （2）迭代器遍历的原理：
        • （3）迭代器源码分析：
        • （4）总结：
      • `2.2.2 增强for循环遍历：`
      • `2.2.3 foreach遍历：`
    • 2.3 List集合
      • （1）和索引相关的方法：
      • （2）list集合的遍历方法：
    • 2.4 数据结构
      • 2.4.1 栈和队列
      • 2.4.2 数组
      • 2.4.3 链表
      • 2.4.4 总结
    • 2.5 ArrayList类和LinkedList类
      • 2.5.1 ArrayList类：
        • （1）ArrayList长度可变原理：
      • 2.5.2 LinkedList类：

1、集合的介绍

1.1 概念

在这里插入图片描述

1.2 集合的分类

在这里插入图片描述

注：集合分为单列集合 和 双列集合

  • 单列集合：一次添加一个元素，实现了Collection接口。
  • 双列集合：一次添加两个元素，实现了Map接口。

2、单列集合：Collection

在这里插入图片描述
注：Collection集合，可以分为List集合 和 Set集合

  • List集合：存取有序、有索引、可以存储重复的元素。
  • Set集合：存取无序、没有索引、不可以存储重复的元素。

2.1 Collection的使用

在这里插入图片描述

package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest1 {
    /**
     * Collection的常用方法：
     *     public boolean add(E e):把给定的对象添加到当前集合中
     *     public void clear():清空集合中所有的元素
     *     public boolean isEmpty():判断当前集合是否为空
     *     public boolean remove(E e):把给定的对象在当前集合中删除
     *     public boolean contains(Object obj):判断当前集合中是否包含给定的对象
     *     public int size():返回集合中元素的个数（集合的长度）
     *
     */
    public static void main(String[] args) {
        //以多态的形式创建集合对象，调用单列集合中的共有方法
        Collection<String> c = new ArrayList<>();

        //1、add(E e):把给定的对象添加到当前集合中
        boolean b1 = c.add("张三");
        boolean b2 = c.add("李四");
        boolean b3 = c.add("王五");
        System.out.println(b1);//true 返回是否添加成功的状态
        System.out.println(b2);//true
        System.out.println(b3);//true
        System.out.println(c);//[张三, 张三, 张三]

        //2、clear():清空集合中所有的元素
        c.clear();
        System.out.println(c);//[]

        //3、isEmpty():判断当前集合是否为空
        System.out.println(c.isEmpty());//true

        //4、remove(E e):把给定的对象在当前集合中删除
        c.add("马四");
        c.add("赵武");
        boolean remove = c.remove("马四");//返回值为是否删除成功的标记：删除存在的对象则返回true，删除不存在的对象则返回false
        System.out.println(c);//[赵武] 可以发现马四已经被删除了

        //5、contains(Object obj):判断当前集合中是否包含给定的对象
        boolean contains1 = c.contains("平平");
        System.out.println(contains1);//false 不包含则返回false
        boolean contains2 = c.contains("赵武");
        System.out.println(contains2);//true 包含则返回true

        //6、size():返回集合中元素的个数（集合的长度）
        System.out.println(c.size());//1
    }
}

2.2 集合的通用遍历方式

在这里插入图片描述

2.2.1 迭代器遍历：

（1）例子：
package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionTest3 {
    /**
     * public Iterator<E> iterator():获取遍历集合的迭代器
     *     1、public E next():从集合中获取一个元素
     *          注：如果next()调用超过了集合的大小，就会出现 NoSuchElementException 异常
     *     2、public boolean hasNext():如果任有元素可以迭代，则返回true
     */
    public static void main(String[] args) {
        Collection<Student> c = new ArrayList<>();
        Student s1 = new Student("张三", 11);//Student是自定义创建的类
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 31);
        //添加三个对象
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //1、获取迭代器
        Iterator<Student> iterator = c.iterator();

        //2、循环判断集合中是否还有元素
        while (iterator.hasNext()){//
            //3、调用next方法，从集合中获取一个元素
            Student next = iterator.next();
            System.out.println(next);
        }
    }
}
（2）迭代器遍历的原理：

在这里插入图片描述

总结：next()方法取出一个元素后，指针会向后移动一位。

（3）迭代器源码分析：

在这里插入图片描述

（4）总结：

在这里插入图片描述

2.2.2 增强for循环遍历：

在这里插入图片描述

package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;

public class CollectionTest4 {
    /**
     * 使用增强for循环遍历
     *
     */
    public static void main(String[] args) {
        Collection<Student> c = new ArrayList<>();
        Student s1 = new Student("张三", 11);//Student是自定义创建的类
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 31);
        //添加三个对象
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //使用增强for循环遍历
        for (Student s : c){
            System.out.println(s);
        }
    }
}

注：增强for循环的遍历方式，其实就是迭代器遍历，当编译成字节码文件后，发现增强for循环代码就会转换为迭代器遍历方式。

2.2.3 foreach遍历：

package com.itheima.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Consumer;

public class CollectionTest4 {
    public static void main(String[] args) {
        Collection<Student> c = new ArrayList<>();
        Student s1 = new Student("张三", 11);//Student是自定义创建的类
        Student s2 = new Student("李四", 21);
        Student s3 = new Student("王五", 31);
        //添加三个对象
        c.add(s1);
        c.add(s2);
        c.add(s3);

        //使用foreach方法遍历
        c.forEach(e-> System.out.println(e));
    }
}

注：foreach底层也是迭代器遍历。

2.3 List集合

在这里插入图片描述

（1）和索引相关的方法：

在这里插入图片描述

package com.itheima.collection.list;

import java.util.ArrayList;
import java.util.List;

public class ListDemo1 {
    /**
     * List接口的特点：存取有序、有索引、可以存储重复
     * 和索引有关的API:
     *     public void add(int index, E element):在指定的索引位置，添加元素
     *     public E set(int index, E element):根据索引修改集合中的元素
     *     public E remove(int index):根据索引删除集合中的元素
     *     public E get(int index):返回指定索引处的元素
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();

        //1、add(int index, E element):在指定的索引位置，添加元素
        list.add("lisi");
        list.add("wangwu");
        list.add("maliu");
        list.add(1, "lisi");//在1号位置添加元素，原来1号位置及后面的元素都向后移动一位
        System.out.println(list);//[lisi, lisi, wangwu, maliu]

        //2、set(int index, E element):根据索引修改集合中的元素
        list.set(1, "马四");//修改索引为1的元素为马四
        System.out.println(list);//[lisi, 马四, wangwu, maliu]

        //3、remove(int index):根据索引删除集合中的元素
        list.remove(1);//删除索引为1的元素
        System.out.println(list);//[lisi, wangwu, maliu]

        //4、get(int index):返回指定索引处的元素
        System.out.println(list.get(1));//wangwu 获取索引为1的元素
    }
}

注意：remove()方法，如果list集合中存储的本身就是int类型，那么删除时会被当做索引，因此需要手动装箱，如下例子：

package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
        List<Integer> ll = new ArrayList<>();
        ll.add(111);
        ll.add(222);
        ll.add(333);
//        ll.remove(222);//222会被当作索引，这里就会报空指针，手动装箱，如下
        ll.remove(Integer.valueOf(222));
        System.out.println(ll);//[111, 333]
    }
}

（2）list集合的遍历方法：

在这里插入图片描述

package com.itheima.collection.list;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class ListDemo2 {
    /**
     * List集合的遍历方式：
     *     1、普通for循环
     *     2、迭代器遍历
     *     3、增强for循环
     *     4、foreach方法
     *     5、ListIterator（List集合特有的迭代器）
     *
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("111");
        list.add("222");
        list.add("333");
        list.add("444");

        //1、普通for循环
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("--------------------");

        //2、迭代器遍历
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("--------------------");

        //3、增强for循环
        for (String s : list){
            System.out.println(s);
        }

        System.out.println("--------------------");

        //4、foreach方法
        list.forEach(item -> System.out.println(item));

        System.out.println("--------------------");

        //5、ListIterator（List集合特有的迭代器）
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        //上述ListIterator遍历和正常的一样，不一样的是可以倒叙遍历，同时增加了add()方法
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }
    }
}

注意：在遍历过程中做删除、增加操作，可能会发生并发修改异常。
在这里插入图片描述
在这里插入图片描述

package com.itheima.collection.list;

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;

/**
 * Title: ListDemo3
 * Describe: 类的功能
 * Name: masizhou
 * Date: 2024/7/13
 * Copyright: @2022 by masizhou
 */

public class ListDemo3 {
    /**
     * 在遍历过程中，如果有添加、删除元素操作时，会出现并发修改异常：ConcurrentModificationException
     * 【场景】：使用[迭代器]遍历集合的过程中，调用了[集合对象]的添加，删除方法，机会出现此异常
     * 【解决方案】：迭代器的遍历过程中，不允许使用集合对象的添加或删除，那就是用迭代器，自己的添加或删除方法
     *              删除方法：普通的迭代器有
     *              添加方法：普通的迭代器没有，需要使用list集合特有的迭代器
     *
     */
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");

        /*
        下面代码使用的是增强for循环，其实底层也是使用迭代器的方法，
        但这个时候增加和删除只能拿到集合的方法，没法使用迭代器的方法
        【解决方法】：手写迭代器进行遍历---这就是为啥手写迭代器遍历虽然麻烦，但是有特定使用的场景
        */
//        for (String s : list){
//            list.remove("bbb");
//        }
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()){
            String s = listIterator.next();
            if ("aaa".equals(s)){
                listIterator.remove();
                listIterator.add("我是增加的元素");
            }
        }

        System.out.println(list);//[我是增加的元素, bbb, ccc, ddd]
    }
}

注意：
（1）我们在写代码，在遍历过程中需要对一个集合做增加或者删除操作时，一般会放在一个新的集合中，避免索引乱了的问题而导致空指针。
（2）但是为了节省内存，就是要操作原集合，那就使用迭代器的遍历方法，然后用迭代器的add和remove方法做增加和删除操作就可以解决这个问题。

2.4 数据结构

在这里插入图片描述

2.4.1 栈和队列

在这里插入图片描述

2.4.2 数组

在这里插入图片描述

2.4.3 链表

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

2.4.4 总结

在这里插入图片描述

2.5 ArrayList类和LinkedList类

2.5.1 ArrayList类：

在这里插入图片描述

package com.itheima.collection.list;
import java.util.ArrayList;
import java.util.List;

public class ListDemo3 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//多态
        list.add("aaa");
        list.add("bbb");

        System.out.println(list);
    }
}
（1）ArrayList长度可变原理：

在这里插入图片描述

注意：
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

2.5.2 LinkedList类：

在这里插入图片描述

package com.itheima.collection.list;
import java.util.LinkedList;
import java.util.List;

public class ListDemo4 {
    /**
     * LinkedList特有方法：
     *     public void addFirst(E e):头部添加
     *     public void addLast(E e):尾部添加
     *     public E getFirst():获取第一个
     *     public E getLast():获取最后一个
     *     public E removeFirst():删除第一个
     *     public E removeLast():删除最后一个
     *
     */
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("张三");
        linkedList.add("李四");
        linkedList.add("王五");

        //1、addFirst(E e):头部添加
        linkedList.addFirst("玛尔");
        System.out.println(linkedList);//[玛尔, 张三, 李四, 王五]

        //2、addLast(E e):尾部添加
        linkedList.addLast("马六");
        System.out.println(linkedList);//[玛尔, 张三, 李四, 王五, 马六]

        //3、getFirst():获取第一个
        System.out.println(linkedList.getFirst());//玛尔

        //4、getLast():获取最后一个
        System.out.println(linkedList.getLast());//马六

        //5、removeFirst():删除第一个
        LinkedList<String> l1 = new LinkedList<>();
        l1.add("aaa");
        l1.add("bbb");
        l1.add("ccc");
        l1.add("ddd");
        //l1 = [aaa, bbb, ccc, ddd]
        l1.removeFirst();
        System.out.println(l1);//[bbb, ccc, ddd]

        //6、removeLast():删除最后一个
        LinkedList<String> l2 = new LinkedList<>();
        l2.add("aaa");
        l2.add("bbb");
        l2.add("ccc");
        l2.add("ddd");
        //l2 = [aaa, bbb, ccc, ddd]
        l2.removeLast();
        System.out.println(l2);//[aaa, bbb, ccc]
    }
}

在这里插入图片描述

在这里插入图片描述
答：实际上就是从头或者从尾部开始遍历查找：

  • 如果索引比集合长度的一半小，则从头找；
  • 如果索引比集合长度的一半大，则从尾找；

注意！！！
注意！！！
注意！！！
双列集合在Day10里。。。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1924521.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Halcon机器视觉15种缺陷检测案例_2不均匀表面刮伤检测

Halcon机器视觉15种缺陷检测案例_2不均匀表面刮伤检测

2&#xff1a; 不均匀表面刮伤检测 思路 1、获取图像 2、分割图像 3、处理区域 4、获取大&#xff0c;小缺陷 效果 原图 代码 *02 不均匀表面刮伤检测 dev_update_off () dev_close_window ()*****************第一步 获取图像******************* read_image (Image, 2.不…
阅读更多...
集成excel工具：自定义导入回调监听器、自定义类型转换器、web中的读

集成excel工具：自定义导入回调监听器、自定义类型转换器、web中的读

文章目录 I 封装导入导出1.1 定义工具类1.2 自定义读回调监听器： 回调业务层处理导入数据1.3 定义文件导入上下文1.4 定义回调协议II 自定义转换器2.1 自定义枚举转换器2.2 日期转换器2.3 时间、日期、月份之间的互转2.4 LongConverterIII web中的读3.1 使用默认回调监听器3.2…
阅读更多...
NAT地址转换+多出口智能选路，附加实验内容

NAT地址转换+多出口智能选路，附加实验内容

本章主要讲&#xff1a;基于目标IP、双向地址的转换 注意&#xff1a;基于目标NAT进行转换 ---基于目标IP进行地址转换一般是应用在服务器端口映射&#xff1b; NAT的基础知识 1、服务器映射 服务器映射是基于目标端口进行转换&#xff0c;同时端口号也可以进行修改&…
阅读更多...
AI算法14-套索回归算法Lasso Regression | LR

AI算法14-套索回归算法Lasso Regression | LR

套索回归算法概述 套索回归算法简介 在统计学和机器学习中&#xff0c;套索回归是一种同时进行特征选择和正则化&#xff08;数学&#xff09;的回归分析方法&#xff0c;旨在增强统计模型的预测准确性和可解释性&#xff0c; 正则化是一种回归的形式&#xff0c;它将系数估…
阅读更多...
接口基础知识2：http通信的组成

接口基础知识2：http通信的组成

课程大纲 一、http协议 HTTP&#xff08;Hypertext Transfer Protocol&#xff0c;超文本传输协议&#xff09;是互联网中被使用最广的一种网络协议&#xff0c;用于客户端与服务器之间的通信。 HTTP协议定义了一系列的请求方法&#xff0c;例如 GET、POST、PUT、DELETE 等&…
阅读更多...
一篇学通Axios

一篇学通Axios

Axios 是一个基于 Promise 的 HTTP 客户端&#xff0c;用于浏览器和 node.js 环境。它提供了一种简单易用的方式来发送 HTTP 请求&#xff0c;并支持诸如请求和响应拦截、转换数据、取消请求以及自动转换 JSON 数据等功能。 Axios 名字的由来 Axios 的名字来源于希腊神话中的…
阅读更多...
在Linux系统实现瑞芯微RK3588部署rknntoolkit2进行模型转换

在Linux系统实现瑞芯微RK3588部署rknntoolkit2进行模型转换

一、首先要先安装一个虚拟的环境 安装Miniconda包 Miniconda的官网链接：Minidonda官网 下载好放在要操作的linux系统，我用的是远程服务器的linux系统，我放在whl这个文件夹里面，这个文件夹是我自己创建的 运行安装 安装的操作都是yes就可以了 检查是否安装成功,输入下面…
阅读更多...
秋招突击——7/13——多线程编程（基础知识回顾+编程练习 ）

秋招突击——7/13——多线程编程（基础知识回顾+编程练习 ）

文章目录 引言基础知识Synchronized关键字使用方式用于同步方法针对同步块的方法静态方法使用原理解析 Volatile使用方式实现原理 final关键字 编程练习&#xff08;synchronized就能实现&#xff09;双线程轮流打印1-100个人实现参考实现 三线程顺序打出1-100个人实现参考实现…
阅读更多...
笔记 4 ：linux 0.11 中继续分析 0 号进程创建一号进程的 fork () 函数

笔记 4 ：linux 0.11 中继续分析 0 号进程创建一号进程的 fork () 函数

&#xff08;27&#xff09;本条目开始&#xff0c; 开始分析 copy_process () 函数&#xff0c;其又会调用别的函数&#xff0c;故先分析别的函数。 get_free_page &#xff08;&#xff09; &#xff1b; 先 介绍汇编指令 scasb &#xff1a; 以及 指令 sstosd &#xff1a;…
阅读更多...
[USACO24OPEN] Smaller Averages G （单调性优化dp）

[USACO24OPEN] Smaller Averages G （单调性优化dp）

来源 题目 Bessie 有两个长度为 N的数组&#xff08;1≤N≤500&#xff09;。第一个数组的第 i 个元素为 ai​&#xff08;1≤ai​≤10^6&#xff09;&#xff0c;第二个数组的第 i个元素为bi​&#xff08;1≤bi​≤10^6&#xff09;。 Bessie 希望将两个数组均划分为若干非空…
阅读更多...
大数据开发中的数据驱动决策：关键问题与实践指南

大数据开发中的数据驱动决策：关键问题与实践指南

目录 决策前的准备工作1. 我已经掌握了哪些信息&#xff1f;2. 我们已经做出决定了吗&#xff1f;3. 我们需要哪些额外信息以及何时需要&#xff1f; 决策过程中的关键问题1. 我们需要做这个决定吗&#xff1f;2. 错误地做出这个决定的代价是什么&#xff1f; 决策后的反思1. 我…
阅读更多...
主机安全-开源HIDS字节跳动Elkeid安装使用

主机安全-开源HIDS字节跳动Elkeid安装使用

目录 概述什么是HIDSHIDS与NIDS的区别EDR、XDR是啥&#xff1f; Elkeid架构Elkeid Agent && Agent centerElkeid DriverElkeid RASPElkeid HUBService DiscoveryManager安装数据采集规则&告警 参考 概述 什么是HIDS HIDS&#xff08; host-based intrusion detec…
阅读更多...
CentOS7.X系统部署Zabbix6.0版本(可跟做)

CentOS7.X系统部署Zabbix6.0版本(可跟做)

文章目录 一、部署环境说明二、基本环境部署步骤1、环境初始化操作2、部署并配置Nginx3、部署并配置PHP4、测试NginxPHP环境5、部署并配置MariaDB 三、Zabbix-Server部署步骤1、编译安装Zabbix-Server2、导入Zabbix初始化库3、配置Zabbix前端UI4、启动Zabbix-Server5、WEB页面配…
阅读更多...
基于 BERT+BILSTM 实现情感分析分类（附源码）

基于 BERT+BILSTM 实现情感分析分类（附源码）

目录 一、数据集 二、数据清洗和划分 2.1 安装依赖 2.2 清洗和划分 三、下载 Bert 模型 四、训练和测试模型 本文主要基于 Bert 和 BiLSTM 实现情感分类&#xff0c;其中参考了多个博客&#xff0c;具体见参考链接。 源码已上传Gitee : bert-bilstm-in-Sentiment-classi…
阅读更多...
基于JavaSpringBoot+Vue+uniapp微信小程序校园宿舍管理系统设计与实现

基于JavaSpringBoot+Vue+uniapp微信小程序校园宿舍管理系统设计与实现

基于JavaSpringBootVueuniapp微信小程序实现校园宿舍管理系统 目录 第一章 绪论 1.1 研究背景 1.2 研究现状 1.3 研究内容 第二章 相关技术介绍 2.1 Java语言 2.2 HTML网页技术 2.3 MySQL数据库 2.4 Springboot 框架介绍 2.5 VueJS介绍 2.6 ElementUI介绍 第三章 系…
阅读更多...
pytorch训练的时候 shm共享内存不足，导致训练停止

pytorch训练的时候 shm共享内存不足，导致训练停止

1.查看shm情况 df -h /dev/shm内存已经满了&#xff0c;因为之前训练多次训练意外停止到shm中的缓存不能及时被清理 2、手动清理shm 依然没被释放 3、查看关联的进程&#xff0c;一个一个kill lsof |grep deletedkill -9 46619 44618 44617 。。。。。4、搞定
阅读更多...
3011.力扣每日一题7/13 Java（冒泡排序）

3011.力扣每日一题7/13 Java（冒泡排序）

博客主页&#xff1a;音符犹如代码系列专栏&#xff1a;算法练习关注博主&#xff0c;后期持续更新系列文章如果有错误感谢请大家批评指出&#xff0c;及时修改感谢大家点赞&#x1f44d;收藏⭐评论✍ 目录 冒泡排序 解题思路 解题过程 时间复杂度 空间复杂度 冒泡排序 冒…
阅读更多...
jenkins系列-07.轻易级jpom安装

jenkins系列-07.轻易级jpom安装

jpom是一个容器化服务管理工具&#xff1a;在线构建&#xff0c;自动部署&#xff0c;日常运维, 比jenkins轻量多了。 本篇介绍mac m1安装jpom: #下载&#xff1a;https://jpom.top/pages/all-downloads/ 解压&#xff1a;/Users/jelex/Documents/work/jpom-2.10.40 启动前修…
阅读更多...
[论文阅读]MaIL: Improving Imitation Learning with Mamba

[论文阅读]MaIL: Improving Imitation Learning with Mamba

Abstract 这项工作介绍了mamba模仿学习&#xff08;mail&#xff09;&#xff0c;这是一种新颖的模仿学习&#xff08;il&#xff09;架构&#xff0c;为最先进的&#xff08;sota&#xff09;变换器策略提供了一种计算高效的替代方案。基于变压器的策略由于能够处理具有固有非…
阅读更多...
思维+构造，CF 1059C - Sequence Transformation

思维+构造，CF 1059C - Sequence Transformation

一、题目 1、题目描述 2、输入输出 2.1输入 2.2输出 3、原题链接 1059C - Sequence Transformation 二、解题报告 1、思路分析 n 1&#xff0c;2&#xff0c;3的情况从样例已知 考虑n > 4的情况 我们考虑要字典序最大&#xff0c;自然要最早出现非1的数&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023