顺序表 —— Java附加代码

已于 2022-08-01 10:46:43 修改
阅读量361 收藏
点赞数
分类专栏： Java 数据结构 文章标签： java 开发语言 数据结构 算法 后端
于 2022-06-16 07:53:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61635597/article/details/125308623
版权
本文档详细介绍了顺序表的概念、Java实现以及操作方法，包括初始化、打印、尾插、判断是否满、插入、查找、删除和更新等操作。同时，强调了在创建项目时对代码组织和调试的重要性，并提供了完整的顺序表Java代码示例。
摘要由CSDN通过智能技术生成

顺序表 —— Java附加代码

在这里插入图片描述

每博一文案

看到过这样一句话，如果一个人频繁出现在你的梦里，是你的身体感觉到

了你的思念，替你见了一面你朝思暮想的人，而那些出现在梦里的人，大多是再也没见过的人

也许是在某一天告别，也可能连告别都没有。

就散落在天涯，从此天各一方，无论有多么不舍，已经在梦中见过一次.

这是上天在满足你的愿望，提醒你该放下了，谁也不是谁的贵人，都是对方的一个过客

人与人之间的缘分早已注定

而后的许多事，无论如何都无法改变，就像有些人相遇相知，相识恨晚

，但早晚有一天都要分别有人遗憾终身，也有人一笑了之，不是后者

有多薄情，而是他明白。

遇到了就应珍惜，离开了就要放下。

​ ———————— 一禅心灵庙语

文章目录

  • 我们直接上操作

创建项目的注意事项

  • 首先我们要明白一点就是不存在没有完完全全BUG的项目，就像人无完人一样 我们只能不断地对项目进行优化，减少BUG 的出现，但是我们好像并不能完全的消除所有的BUG
  • 而消除bug 的最好的方式就是运行测试+调试
  • 而我们在运行测试+调试 的时候，需要我们控制一定的量 ，我们需要把握住这个量 ，这一点是十分重要的，这样有助于我们快速的发现问题，也就是bug 的所在，从而提高我们的效率，减少我们的bug 的出现
  • 具体的方法，我个人有以下建议：
  1. 首先我们需要对项目进行合理的分类，那个类，那个文件实现什么样的功能： 比如:一个类是用于定义什么类型，方法的 ，另一个类是用于什么头main 的，再另外一个类是用于对于什么功能上的实现的 ，合理的分类，可以提高我们项目的可读性，让我们自身不会因为自己随着代码量的增加，对应功能上的增加而导致我们越敲越乱，越写越蒙
  2. 对于量上我们可以，每实现了两三个 功能就运行测试看看，是否存在错误，如果存在出现了错误，我们可以在一定的量(范围内)，快速的找出哪里出现了问题，从而对它进行调试 ，解决问题，而不是，把项目整体写完了或者是已经实现了好几十个功能，才开始运行测试项目，结果一运行，bug,警告 冒出一大坨，我们先不说，让不让人，抓头发，就是找出问题，恐怕都需要不时间上的浪费吧
  3. 对于代码上的注释，没事多写明白一点，或许有一天，你会感想曾经，那个写了注释的自己或同事
  4. 对于bug 不要害怕，一点一点的调试看看，找出问题的所在，慢慢来，要有耐心，要明白一点现在bug 写的多，以后bug 跟你说拜拜，现在bug ,不解决，bug 天天对你说**“明天见”**

顺序表的实现

  • 顺序表其实就是一种数组，存放连续的数据信息的，稍微有些不同的就是顺序表，
  • 附加了可以实现简单的扩容，从而增加了数据的存储的容量
  • 所以我们可以通过创建数组，实现所谓的顺序表

顺序表的定义

  • 对于属性我们一般尽量私有化
  • 常量我们尽量被static final 关键字修饰
public class MyArrayList {
    private int[] elem; // 定义数组
    private int usedSize; // 有效数据个数
    private static final int intCapacity = 10; // 定义常量数组的初始大小
}

顺序表的初始化

// 顺序表的初始化,这里通过构造方法，初始化
    public MyArrayList() {
        this.usedSize = 0;
        this.elem = new int[10];
    }

顺序表的打印

  • 这个简单对就是对数组循环遍历一波即可
  // 打印顺序表
    public void  disPlay() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i]+",");
        }
        System.out.println();

//        System.out.println(Arrays.toString(this.elem));
    }

顺序表的尾插

  1. 首先我们在插入数据之前需要判断一下，顺序表是否满了
  2. 如果满了，我们就需要扩容上的实现，扩容成功才插入数据
  3. 这里的扩容我们通过方法 Arrays.copyOf 拷贝实现扩容：
  4. 在扩容上我们不能太小，也不能太大了，如果我们太小了，就会存在，我们插入数据时，不停的需要扩容，扩容会影响一定的效率的，就是会存在一定的性能上的损耗，而如果我们扩容太大了，就会导致我们出现大量的空间上的浪费，所以我们需要适当的扩容，一般为原来顺序表的1.5倍或者是2倍
  5. 插入数据，数据的有效个数++
顺序表是否满的实现
  • 判断顺序表的长度是否等于该存放对应数据的个数，等于表示满了，返回 ture ，不等于表示没有满，返回 false
    // 判断顺序表是否满了
    private boolean isFull() {
        return this.elem.length == this.usedSize;
    }
尾插

在这里插入图片描述

// 插入数据,尾插
    public void tailAdd(int data) {
        if(this.isFull()) {
            // 顺序表满了，通过拷贝赋值，扩容2倍
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        // 插入数据
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }

pos位置插入数据

  1. 首先我们需要对 pos 该插入的位置是否合理进行判断：不可以小于 0 ，不可以超出顺序表的范围，
  2. 同样我们对插入的数据时，需要判断顺序表是否满了，满了扩容，扩容成功，才插入数据
  3. 我们需要对原先在该位置的数据进行移动，防止被覆盖
  4. 插入数据，数据的有效个数++

在这里插入图片描述

 // pos位置插入数据
    public void add(int pos ,int data) {
        // 1.判断是否需要扩容
        if(this.isFull()){
            // 扩容
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        // 2.判断pos 的位置是否合理
        if(pos < 0 || pos > this.usedSize) {
            return;
        }
        // 3.移动数据位置
        for(int i = this.usedSize-1;i>= pos;i--) {
            this.elem[i+1] = this.elem[i];
        }
        // 4.插入数据
        this.elem[pos] = data;
        this.usedSize++;
    }

顺序表中查找是否含有该数值

  • 遍历顺序表，查找，存在该数值，返回 true ，不存在该数值，返回 false
// 查找该顺序表中是否含有该数值
    public boolean contains(int toFind) {
        for (int tmp:this.elem) {
            if(toFind == tmp) {
                return true; // 该数值存在
            }
        }
        return false; // 该数值不存在
    }

查找该数值在顺序表中的位置

  • 遍历该顺序表，找到返回该数值所在的下标位置，找不到返回 -1,顺序表中不存在，-1 的下标表示，没有找到(该数值不存在)
 // 查找该数值在顺表中的位置
    public int search(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if(toFind == this.elem[i]) {
                return i; // 找到返回下标
            }
        }
        return -1;  // 没有找到
    }

取出顺序表中某个下标位置的数值

  1. 首先我们需要判断该顺序表是否为空，如果为空的话，不用找了，自定义异常停止执行
  2. 判断给定的下标是否合理
  3. 通过下标访问，取出对应下标的值
// 取出顺序表中某个下标位置的数值
    public int getPos(int pos) {
        // 1. 判断该顺序表是否为空
        if(this.usedSize == 0) {
            throw new RuntimeException("顺序表是空的！");// 自定义异常停止执行
        }
        // 2. 判断该pos 位置是否合理
        if(pos <0 || pos >= this.usedSize) {
            throw new RuntimeException("pos位置不合法");
        } else {
            return this.elem[pos]; // 返回对应下标的数值
        }

    }

删除顺序表中的某个数值

  1. 首先我们需要判断该顺序表是否为空，如果为空的话，不用找了，自定义异常停止执行
  2. 需要获得该数值的下标，我们可以复用 前面我们实现 ：查找该数值在顺序表中的位置 ，来找到该数值的位置
  3. 挪动位置，对需要删除的数据进行覆盖，
  4. 删除(覆盖)成功，有效数据个数–(减减)

在这里插入图片描述

// 删除顺序表中的某个数值
   public void remove(int toRemove) {
       // 1. 判断该顺序表是否为空
       if(this.usedSize == 0) {
           throw new RuntimeException("顺序表是空的！");// 自定义异常停止执行
       }
        //2. 判断该数值是否存在
        int index = this.search(toRemove);
        if(index == -1) {
            System.out.println("该数值不存在,无法删除");
            return;
        }
        // 3.移动数据，实现覆盖删除
        for(int i = index;i<this.usedSize-1;i++) {
            this.elem[i] = this.elem[i+1];
        }
        this.usedSize--;
   }

删除某下标 pos 的数值

  • 和上面删除顺序表中的某个数值是，一样的
  1. 判断该顺序表是否为空，为空就不用删了，自定义异常停止执行
  2. 判断该pos 下标的位置是否合理
  3. 挪动顺序表中的数值，覆盖需要删除的数值，从而达到删除的效果
  4. 删除成功，数据的有效个数 --(减减)
// 删除某下标 pos 的数值
   public void Delete(int pos) {
       // 1. 判断该顺序表是否为空
       if(this.usedSize == 0) {
           throw new RuntimeException("顺序表是空的！");// 自定义异常停止执行
       }
        // 2. 判断该下标是否合理
       if(pos < 0 || pos >= this.usedSize) {
           System.out.println("该下标不合理");
           return;
       } else {
           //3. 下标合理，覆盖实现删除
           for (int i = pos; i < this.usedSize-1; i++) {
               this.elem[i] = this.elem[i+1];
           }
           this.usedSize--;
       }
   }

更新数值

  • 更新数值,在所在下标，更新数值
  1. 判断该下标，是否合理，
  2. 通过下标赋值，更新数值
// 更新数值,在所在下标，更新数值
    public void setPos(int pos,int value) {
        // 判断该下标是否合理
        if(pos < 0 || pos >= this.usedSize) {
            throw new RuntimeException("pos 位置不合法");
        }
        // 合理更新
        this.elem[pos] = value;
    }

清除顺序表

  • Java有自动回收功能，所以我们只需要把，记录的有效数据置为 0 即可
 // 清除顺序表
    public void clear() {
        // 直接将顺序表中的有效数据记录置为 0 ; 即可
        this.usedSize = 0;
        System.out.println("清空成功");
    }
}

顺序表中有关 maIn 的类


public class MyArrayListTest {
    public static void main(String[] args) {
        MyArrayList myList = new MyArrayList();     // 实例化顺序表对象
        for (int i = 1; i <10 ; i++) {
            myList.tailAdd(i);                      // 头插入数据
        }
        myList.disPlay();                           // 打印顺序表
        myList.tailAdd(10);                    // 头插入数值 10
        myList.disPlay();                           // 打印顺序表
        myList.add(3,11);                 // 在 pos 位置插入数值
        myList.add(11,11);                // 在 pos 位置插入数值
        myList.disPlay();                           // 打印数值
        System.out.println(myList.contains(9));     // 查找该顺序表中是否含有该数值
        System.out.println(myList.contains(99));    // 查找该顺序表中是否含有该数值
        System.out.println(myList.search(4)); // 查找该数值在顺表中的位置
        System.out.println(myList.search(99)); // 查找该数值在顺表中的位置
        System.out.println(myList.getPos(3));       // 取出顺序表中某个下标位置的数值
//        System.out.println(myList.getPos(20));    // 取出顺序表中某个下标位置的数值
        myList.remove(4);                 // 删除顺序表中的某个数值
        myList.disPlay();                           // 打印顺序表
//        myList.remove(0);
        System.out.println("*********************");
        myList.Delete(0);                     // 删除某下标 pos 的数值
        myList.disPlay();                          // 打印顺序表
        myList.Delete(2);                     // 删除某下标 pos 的数值
        myList.disPlay();
        myList.setPos(0,100);           // 更新数值,在所在下标，更新数值
        myList.setPos(8,999);           // 更新数值,在所在下标，更新数值
        myList.disPlay();
        myList.clear();                            // 清除顺序表
        myList.disPlay();
    }


}

完整的顺序表的代码

import java.util.Arrays;

public class MyArrayList {
    private int[] elem; // 定义数组
    private int usedSize; // 有效数据个数
    private static final int intCapacity = 10; // 定义常量数组的初始大小


    // 顺序表的初始化,这里通过构造方法，初始化
    public MyArrayList() {
        this.usedSize = 0;
        this.elem = new int[10];
    }


    // 打印顺序表
    public void  disPlay() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i]+",");
        }
        System.out.println();

//        System.out.println(Arrays.toString(this.elem));
    }


    // 判断顺序表是否满了
    private boolean isFull() {
        return this.elem.length == this.usedSize;
    }


    // 插入数据,尾插
    public void tailAdd(int data) {
        if(this.isFull()) {
            // 顺序表满了，通过拷贝赋值，扩容2倍
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        // 插入数据
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }


    // pos位置插入数据
    public void add(int pos ,int data) {
        // 1.判断是否需要扩容
        if(this.isFull()){
            // 扩容
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        // 2.判断pos 的位置是否合理
        if(pos < 0 || pos > this.usedSize) {
            return;
        }
        // 3.移动数据位置
        for(int i = this.usedSize-1;i>= pos;i--) {
            this.elem[i+1] = this.elem[i];
        }
        // 4.插入数据
        this.elem[pos] = data;
        this.usedSize++;
    }



    // 查找该顺序表中是否含有该数值
    public boolean contains(int toFind) {
        for (int tmp:this.elem) {
            if(toFind == tmp) {
                return true; // 该数值存在
            }
        }
        return false; // 该数值不存在
    }



    // 查找该数值在顺表中的位置
    public int search(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if(toFind == this.elem[i]) {
                return i; // 找到返回下标
            }
        }
        return -1;  // 没有找到
    }



    // 取出顺序表中某个下标位置的数值
    public int getPos(int pos) {
        // 1. 判断该顺序表是否为空
        if(this.usedSize == 0) {
            throw new RuntimeException("顺序表是空的！");// 自定义异常停止执行
        }
        // 2. 判断该pos 位置是否合理
        if(pos <0 || pos >= this.usedSize) {
            throw new RuntimeException("pos位置不合法");
        } else {
            return this.elem[pos]; // 返回对应下标的数值
        }

    }



    // 删除顺序表中的某个数值
   public void remove(int toRemove) {
       // 1. 判断该顺序表是否为空
       if(this.usedSize == 0) {
           throw new RuntimeException("顺序表是空的！");// 自定义异常停止执行
       }
        //2. 判断该数值是否存在
        int index = this.search(toRemove);
        if(index == -1) {
            System.out.println("该数值不存在,无法删除");
            return;
        }
        // 3.移动数据，实现覆盖删除
        for(int i = index;i<this.usedSize-1;i++) {
            this.elem[i] = this.elem[i+1];
        }
        this.usedSize--;
   }



   // 删除某下标 pos 的数值
   public void Delete(int pos) {
       // 1. 判断该顺序表是否为空
       if(this.usedSize == 0) {
           throw new RuntimeException("顺序表是空的！");// 自定义异常停止执行
       }
        // 2. 判断该下标是否合理
       if(pos < 0 || pos >= this.usedSize) {
           System.out.println("该下标不合理");
           return;
       } else {
           //3. 下标合理，覆盖实现删除
           for (int i = pos; i < this.usedSize-1; i++) {
               this.elem[i] = this.elem[i+1];
           }
           this.usedSize--;
       }

   }



   // 更新数值,在所在下标，更新数值
    public void setPos(int pos,int value) {
        // 判断该下标是否合理
        if(pos < 0 || pos >= this.usedSize) {
            throw new RuntimeException("pos 位置不合法");
        }
        // 合理更新
        this.elem[pos] = value;
    }


    // 清除顺序表
    public void clear() {
        // 直接将顺序表中的有效数据记录置为 0 ; 即可
        this.usedSize = 0;
        System.out.println("清空成功");
    }
}

最后:

限于自身水平，其中存在的错误希望大家，给予指教，韩信点兵——多多益善，谢谢大家！后会有期，江湖再见 ！

ChinaRainbowSea
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础学习总结（170）——Java8并发工具类CompletableFuture学习总结
科技D人生
01-14 412
1、What's a CompletableFuture? 首先了解什么是CompletableFuture，它是用于Java中的异步编程。异步编程是一种编写非阻塞代码的方法，它通过在主应用程序线程独立的线程上运行任务，并通知主线程其进度、完成或失败。 这样，你的主线程就不会阻塞、等待任务的完成，它可以并行地执行其他任务。 拥有这种并行性可以极大地提高程序的性能。 2、Future vs CompletableFuture CompletableFuture是Java Future API的扩展，该.
Java基础学习总结（33）——Java8 十大新特性详解
科技D人生
12-25 1981
Java8 十大新特性详解 本教程将Java8的新特新逐一列出，并将使用简单的代码示例来指导你如何使用默认接口方法，lambda表达式，方法引用以及多重Annotation，之后你将会学到最新的API上的改进，比如流，函数式接口，Map以及全新的日期API本教程将用带注释的简单代码来描述新特性，你将看不到大片吓人的文字。 一、接口的默认方法 Java 8允许我们给接口添加一个
顺序表java实现
09-30
对于数据结构中顺序表的实现，建立了一个接口、两个类。通过在类中调用，实现顺序表功能。
java实现顺序表代码
Nabandon的博客
01-09 248
package JAVA0108; import com.sun.xml.internal.ws.wsdl.writer.UsingAddressing; class SqeList{ private int[] datas=new int[100]; private int size=0; public int getSize() { return ...
【Java数据结构】顺序表的代码实现
ImwaterP的博客
11-05 993
顺序表 顺序表其实就是一个写到类中的数组。写到类中就可以面向对象了。实现增删改查。 顺序表特点 物理上和逻辑上都是连续的 插入和删除元素，必须移动元素。（时间复杂度：O（N）） 扩容也是问题 可以实现随机读取（查找时间复杂度：O（1）) 顺序表的代码目录public class SeqList { // 打印顺序表 public void display() { } // 在 pos 位置新增元素 public void add(int pos, int data) { } // 判定是否包含某个元
顺序表java实现代码
coderchem的博客
11-09 424
package com.List; public class SqList { private static final int MaxLength = 200; //可能出现的最大值 public Integer length = 0; //存放的实际长度 public Book[] arr ; //存放方式 public boolean InitList(SqLi...
顺序表JAVA代码
b44431的博客
05-26 158
publicclassSeqList{ final int defaultSize =10; //默认的顺序表的最大长度 int maxSize; //最大长度 int size; //当前长度 Object[] lis...
秋招准备之——Java虚拟机
MeteorChenBo的博客
06-12 2912
前段时间看了周志明老师的《深入理解Java虚拟机》，加上自己在看的过程中查找的一些资料和理解，做了一些笔记，今天乘着复习，在这里分享一下。 一、Java内存区域与内存溢出异常 1.运行时数据区域 1.程序计数器： 当前线程所执行字节码的行号指示器，线程私有 2.虚拟机栈： 描述方法执行的线程内存模型，每个方法执行的时候，会同步创建一个帧栈存储局部变量等信息。与方法中的局部变量紧密相关，局部变量会存放在局部变量表中，在编译期间，局部变量表所需的空间就确定了。局部变量中的存储空间以局部变量槽表示，long和
数据结构与算法分析——java语言描述第三版图论部分java实现，使用邻接表实现图论相关算法。
xiaolian_hust的博客
03-27 489
这篇文章是笔者，学习《数据结构与算法分析——java语言描述第三版》一书的第九章图论部分，根据书中的提示加上自己的理解，编写的源代码。注意点：1.使用HashMap + LinkedList的方式来实现邻接表。2.实现了广度优先搜索，及其应用（无圈图中的单源最短路径问题，关键路径分析），深度优先搜索及其应用（无向图中的割点寻找）3.后续还会陆续更新第九章的其他问题。import java.util...
Java虚拟机(一)——Java内存区域划分
BridgeGeorge
08-18 1550
介绍  Java虚拟机在执行Java程序的过程中会把他所管理的内存划分为若干个不同的数据区域。这些区域都有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而存在，有些区域则依赖用户线程的启动和结束而建立和销毁。运行时数据区域  Java虚拟机在执行Java程序的过程中会把他所管理的内存划分为若干个不同的数据区域。Java虚拟机规范将JVM所管理的内存分为以下几个运行时数据区：程序计数器
顺序表实现
11-05
Java顺序表的学习实现代码，支持多种数据类型的临时存储
实现一个简单的顺序表（Java代码）
m0_63036262的博客
04-10 3174
在本篇文章，主要写一些关于顺序表的简单操作。在介绍顺序表的简单操作前，先来了解一下什么是顺序表？顺序表的简单操作又有那些呢？增删改除算不算呢？下面让我们一起来了解一下吧！
用java生成一个附加码。
浮萍之乡
05-22 697
好久没有写个东西了.最近好忙.希望大家能够用的上这个附加码./***@作者 pxjianke*@目标  生成附加码，免得别人破解密码**/import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;
Java数据结构——代码实现顺序表的操作
热门推荐
chenchenchencl的博客
09-17 2万+
一文速学顺序表的代码实现
Java顺序表代码的实现
TIANHE_的博客
04-02 220
import java.util.Arrays; public class MyArrayList { private int[] elem; private int useSide; private static final int DEFAULT_SIZE = 4; public MyArrayList(){ this.elem = new...
顺序表（Java实现）
m0_52066789的博客
11-06 597
什么是顺序表？ 我们说它是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。同时它在逻辑上也是一条连续的直线。 顺序表又是什么用？ 顺序表既然是一种表，那么它最基本的功能就是存储数据。除此之外，它还能对存储在里面的数据进行增删查改等操作。 顺序表和数组有什么区别？ 相同点： 都是用一段连续的存储单元用来存放数据（物理地址和逻辑上都是线性的）。 不同点： 数组想要对元素进行增删查改等一系列动作时，就需要借助外部的一些方法或者自己手动去实现。而顺序表则不同，只要实例
java顺序表代码_顺序表java实现代码
weixin_36446407的博客
02-17 351
package com.List;public class SqList {private static final int MaxLength = 200; //可能出现的最大值public Integer length = 0; //存放的实际长度public Book[] arr ; //存放方式public boolean InitList(SqList L){ //初始...
java顺序表代码_顺序表JAVA代码
weixin_30583711的博客
02-26 118
lego blocks1.题目描述 https://www.hackerrank.com/challenges/lego-blocks 2.解法分析 这题乍看一下觉得应该可以用动态规划来做,但是却死活想不到最优子结构,在网 ...Android 拦截短信public class SMSMess extends BroadcastReceiver { @Override public void on...
java实现顺序表
lzhcr123的博客
12-06 2040
顺序表的概念 用一段地址连续的存储单元依次存储数据元素的线性结构。 由于数组类型也具有随机存取的特性，因此，也可以用数组来描述数据结构中的顺序存储结构。 顺序表的特点 1.优点： 便于随机存取，读取数据的速度快 2.缺点： 由于它顺序的存储结构，不便于插入和删除 代码实现 1.把顺序表的基本操作放在接口中，子类继承接口即可 interface ISeqList { /** *...
顺序表——调整数据元素
最新发布
09-12
顺序表是一种线性表的存储结构，数据元素按照顺序存放在连续的内存空间中。如果需要调整顺序表中的数据元素，可以通过以下几种方式： 1. 插入操作：在指定位置插入一个新的元素。插入操作会使得插入位置及其之后的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值