《Java数据结构》--顺序表

已于 2024-04-17 10:01:29 修改
阅读量886 收藏 8
点赞数 19
分类专栏： 数据结构 文章标签： java 数据结构 开发语言
于 2024-04-17 09:46:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73290424/article/details/137825845
版权

📕前言

📖文章吸纳了一些大佬的文章，但大部分纯手敲哦，欢迎光临小林课堂！！！

在学习顺序表之前呢，我们得先了解以下  " 何为线性表？"

线性表：是一种在实际中广泛使用得数据结构，常见的线性表有：顺序表，链表，栈，队列 ...

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

我们的今天学习的顺序表的底层结构其实就是 一个数组

顺序表 是使用数组 来完成的一种结构

顺序表介绍：

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。

顺序表一般可以分为：

  1. 静态顺序表：使用定长数组存储元素。( 本篇内容主要围绕静态顺序表展开 )
  2. 动态顺序表：使用动态开辟的数组存储

模拟实现 顺序表

为什么要模拟实现：
自己模拟实现 简易版的 顺序表的增删查改等主要功能，大致理解顺序表的设计思想
再对比学习 Java 提供的集合类当中的 ArrayList ，在学习 Java 的 ArrayList 常用方法的同时，也能学习源码的思想

 📒本文将创建两个Java文件：

My ArraysList.java 用于顺序表的实现，

Test.java 用于对顺序表里的各个接口的测试

顺序表功能接口概览

import java.util.Arrays;

public class MyArrayList {
    private int[] elem;//用来存放数据元素
    private int usedSize; //代表当前顺序表当中的有效数据个数
    //为什么不初始化 usedSize 因为引用类型不初始化的话，默认值就是 零
    //

    private static final int DEFAULT_SIZE = 2;//定义一个静态常量，更加安全
    
    //初始化顺序表
    public MyArrayList() {//这就默认大小是2
        this.elem = new int[DEFAULT_SIZE];
    }

    /*
     * 指定容量
     *  initCapacity
     * */
    public MyArrayList(int initCapacity) {
        this.elem = new int[initCapacity];
    }



    // 新增元素,默认在数组最后新增
    public void add(int data) { }

    // 在 pos 位置新增元素
    public void add(int pos, int data) { }

    // 判定是否包含某个元素
    public boolean contains(int toFind) { return true; }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) { return -1; }

    // 获取 pos 位置的元素
    public int get(int pos) { return -1; }

    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) { }

    //删除第一次出现的关键字key
    public void remove(int toRemove) { }

    // 获取顺序表长度
    public int size() { return 0; }

    // 清空顺序表
    public void clear() { }

    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    public void display() { }
}

  基本功能的实现

🌰判断顺序表内存是否已经满了

public boolean isFull() {
        if (this.usedSize == this.elem.length) {
            return true;
        }
        return false;
    }

🌰对顺序表进行扩容

 //对顺序表进行扩容
private void expand() {
        this.elem = Arrays.copyOf(
                this.elem, this.elem.length * 2);
        System.out.println("已经成功扩容至原来的两倍");
    }

🌰打印顺序表

    /*
     * 打印顺序表
     * 实际上是 遍历数组
     * */
    
//打印的第一种方式
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + "  ");
        }
        System.out.println();
    }

//打印的第二种方式,用Arrays.toString直接打印
     public void display(){
        System.out.println(Arrays.toString(this.elem));
    }

🌰获取顺序表的有效长度

// 获取顺序表的有效长度
    public int size() {
        return this.usedSize;
    }

🌰清空顺序表

// 清空顺序表
    public void clear() {
        /*for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
        //如果这是引用类型,就要这么写,要把一个个对象置为 null 空
        */
        this.usedSize = 0;// 注意有效数组长度也要清零
    }

 🌰自定义异常 （检查 pos 位置是否合法）

    /*
     * 检查 pos 位置是否合法
     * @param pos
     * */

    private void checkPos(int pos) {//用 private 只是希望在这个类里面使用
        if (pos < 0 || pos >= this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常

//            System.out.println("新增位置不合法");
//            return;

        }
    }

定义的异常接口功能

越界时，抛出异常

/**
 * @Author XiaoLin
 * @Description: 位置超过，越界，抛出异常
 * 自定义异常
 */

public class PosOutOfBoundException extends RuntimeException{
    public PosOutOfBoundException() {
    }

    public PosOutOfBoundException(String message) {
        super(message);
    }
}

顺序表四大功能（增删查改）

一，增加数据

🔢头插

//新增元素，在数组最前面新增
    public void addHead(int data) {
        if (isFull()) {
            System.out.println("数组满了，需要扩容");
            expand();
        }else {
            // 从usedSize下标开始，不会数组越界( 此时的 elem.length > usedSize )
            for (int i = this.usedSize; i > 0 ; --i) {
                this.elem[i] = this.elem[i - 1]; //从后往前挪动数据，为的是给顺序表的表头腾出来
            }
            this.elem[0] = data; //在顺序表开头插入
            this.usedSize++;     //数组有效长度加一
        }
        
    }

🔢尾插

 // 新增元素,默认在数组最后新增
 //数据结构是一门逻辑非常严谨的学科

    public void add(int data) {
        if (isFull()) {
            System.out.println("数组满了,需要扩容");
            //扩容
            expand();
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }

🔢指定下标插入

  1. 判断pos位置是否合法 （在顺序表中，数据是连续的，中间不能有空缺）
  2. 判断顺序表是否满了，如果满了，需要扩容
  3. 插入数据（可能需要挪动元素） 
 // 在 pos 位置新增元素
    public void add(int pos, int data) {
        if (pos < 0 || pos > this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常

            //System.out.println("新增位置不合法");
            //return;

        }
        //重载
        if (isFull()) {
            //扩容
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

 二，删除数据

🔢头插

//删除表头元素
    public void removeHead() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        //从第一个元素开始，用后面元素的值覆盖掉前面的值，遍历整个数组就相当于把第一个元素用覆盖的方式抹去了
        for (int i = 1; i < this.usedSize; i++) {
            this.elem[i - 1] = this.elem[i];
        }
        this.elem[this.usedSize -1] = 0;// 现在的最后一个元素是原来的倒数第二个元素，所以原来的最后一个有效元素要置0
        this.usedSize--;// 不要忘记改变有效数组的长度
    }

🔢尾插

//删除表尾元素
    public void removeTail() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        this.elem[this.usedSize - 1] = 0;// 直接将最后一个元素置0就完成了尾删
        this.usedSize--;
    }

🔢指定下标元素的删除

//指定下标元素的删除
    public void removePos(int pos) {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        checkPos(pos);// 检查输入的pos下标合不合法
        for (int i = pos; i < this.usedSize - 1; ++i) {
            this.elem[i] = this.elem[i + 1];// 从要删除的下标开始，用后边元素的值覆盖掉前面的值，就完成了删除
        }
        this.elem[this.usedSize - 1] = 0;// 要完整的删除，将挪动的最后一个元素的原本位置 置空
        this.usedSize--;
    }

 🔢删除首次出现的指定元素

//删除第一次出现的关键字key
    public void remove(int toRemove) {
        int index = indexOf(toRemove);
        if (index == -1) {
            System.out.println("没有这个数据！！");
            return;
        }
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        //this.elem[usedSize-1] = null; //如果这是引用类型就要这句,
        
        this.usedSize--;
    }

三，查找数据

 🔢获取指定位置的元素

  1. 考虑要获取的位置是否合法
  2. 返回指定位置的元素 
// 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }

  🔢获取指定元素所在的位置

// 获取 pos 位置的元素
    public int get(int pos) {
        checkPos(pos);//调用自定义异常方法
        //没找到就会报异常
        return this.elem[pos];
    }

  🔢查找表中是否包含某个元素

// 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

四，修改数据

🙌首先考虑修改的位置是否合法

🙌考虑特殊情况

// 给 pos 位置的元素设为 value  [ 更新 ]

public void set(int pos, int value) {
        checkPos(pos); //判断要修改的位置合不合法
        this.elem[pos] = value;
    }

总代码

📖MyArrayList.java 

import java.util.Arrays;

/**
 * @Author XiaoLin
 * @Description:
 */
public class MyArrayList {
    private int[] elem;//用来存放数据元素
    private int usedSize; //代表当前顺序表当中的有效数据个数
    //为什么不初始化 usedSize 因为引用类型不初始化的话，默认值就是 零
    //

    private static final int DEFAULT_SIZE = 2;//定义一个静态常量

    public MyArrayList() {//这就默认大小是2
        this.elem = new int[DEFAULT_SIZE];
    }



    /*
     * 指定容量
     *  initCapacity
     * */
    public MyArrayList(int initCapacity) {
        this.elem = new int[initCapacity];
    }


    /*
     * 打印顺序表
     * 实际上是 遍历数组
     * */
    public void display() {
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + "  ");
        }
        System.out.println();
    }
    public void display2(){
        System.out.println(Arrays.toString(this.elem));
    }

    
    //新增元素，在数组最前面新增
    public void addHead(int data) {
        if (isFull()) {
            System.out.println("数组满了，需要扩容");
            expand();
        }else {
            // 从usedSize下标开始，不会数组越界( 此时的 elem.length > usedSize )
            for (int i = this.usedSize; i > 0 ; --i) {
                this.elem[i] = this.elem[i - 1]; //从后往前挪动数据，为的是给顺序表的表头腾出来
            }
            this.elem[0] = data; //在顺序表开头插入
            this.usedSize++;     //数组有效长度加一
        }

    }


    // 新增元素,默认在数组最后新增
    //数据结构是一门逻辑非常严谨的学科
    public void add(int data) {
        if (isFull()) {
            System.out.println("数组满了,需要扩容");
            //扩容
            expand();
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }
    

    //扩容
    private void expand() {
        this.elem = Arrays.copyOf(
                this.elem, this.elem.length * 2);
        System.out.println("已经成功扩容至原来的两倍");
    }
    


    public boolean isFull() {
        if (this.usedSize == this.elem.length) {
            return true;
        }
        return false;
    }
    

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        if (pos < 0 || pos > this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常
//            System.out.println("新增位置不合法");
//            return;
        }
        //重载
        if (isFull()) {
            //扩容
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;

    }


    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        return -1;
    }
    

    // 获取 pos 位置的元素
    public int get(int pos) {
        checkPos(pos);//调用自定义异常方法
        return this.elem[pos];
    }

    
    // 给 pos 位置的元素设为 value  [ 更新 ]
    public void set(int pos, int value) {
        checkPos(pos);
        this.elem[pos] = value;
    }


    /*
     * 检查 pos 位置是否合法
     * @param pos
     * */

    private void checkPos(int pos) {//用 private 只是希望在这个类里面使用
        if (pos < 0 || pos >= this.usedSize) {
            throw new PosOutOfBoundException(pos + "  位置不合法");//自定义异常

//            System.out.println("新增位置不合法");
//            return;

        }
    }
    

    //判断当前顺序表是否为空
    public boolean isempty() {
        if(this.usedSize == 0){
            return true;//空的
        }
        else return false; //还没空
    }

    
    //删除表头元素
    public void removeHead() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        //从第一个元素开始，用后面元素的值覆盖掉前面的值，遍历整个数组就相当于把第一个元素用覆盖的方式抹去了
        for (int i = 1; i < this.usedSize; i++) {
            this.elem[i - 1] = this.elem[i];
        }
        this.elem[this.usedSize -1] = 0;// 现在的最后一个元素是原来的倒数第二个元素，所以原来的最后一个有效元素要置0
        this.usedSize--;// 不要忘记改变有效数组的长度
    }
    

    //删除表尾元素
    public void removeTail() {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        this.elem[this.usedSize - 1] = 0;// 直接将最后一个元素置0就完成了尾删
        this.usedSize--;
    }


    //指定下标元素的删除
    public void removePos(int pos) {
        if (isempty()){
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        checkPos(pos);// 检查输入的pos下标合不合法
        for (int i = pos; i < this.usedSize - 1; ++i) {
            this.elem[i] = this.elem[i + 1];// 从要删除的下标开始，用后边元素的值覆盖掉前面的值，就完成了删除
        }
        this.elem[this.usedSize - 1] = 0;// 要完整的删除，将挪动的最后一个元素的原本位置 置空
        this.usedSize--;
    }


    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        int index = indexOf(toRemove);
        if (index == -1) {
            System.out.println("没有这个数据！！");
            return;
        }
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
//        this.elem[usedSize-1] = null; //如果这是引用类型就要这句,
        this.usedSize--;
    }


    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }
    

    // 清空顺序表
    public void clear() {
        /*for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = null;
        }
        //如果这是引用类型,就要这么写,要把一个个对象置为 null 空
        */
        this.usedSize = 0;// 注意有效数组长度也要清零
    }

    // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    
}

📖Test.java

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

/**
 * @Author XiaoLin
 * @Description:
 */
public class Test01_顺序表 {

    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        myArrayList.add(4);
        myArrayList.add(5);

        myArrayList.display();

        myArrayList.add(3, 15);
        myArrayList.display();

        System.out.print(myArrayList.contains(3));
        System.out.println("   下标为：" + myArrayList.indexOf(3));
        System.out.println("============================");
        System.out.println("获取 pos 位置的元素   " + myArrayList.get(3));//获取 pos 位置的元素
        System.out.println("============================");
        System.out.println("给 pos 位置的元素设为 value  [ 更新 ]");
        myArrayList.set(2, 11);
        myArrayList.display();
        System.out.println("============================");
        System.out.println("删除关键字key");
        myArrayList.remove(2);
        myArrayList.display();
        System.out.println("============================");
        System.out.println("清空顺序表");
        myArrayList.clear();
        myArrayList.display();

    }
}

 最后

本篇内容主要是对数据结构中【顺序表】内容的介绍，一方面介绍了如何模拟实现简易的顺序表，另外一方面介绍了Java集合框架中的【ArrayList】类的基本使用【ArrayList】

😎顺序表的优点

😣当然也有缺点！！！ 

所以： 怎么做到随用随分配呢？？？

 

总结：什么功能就用其最适的数据结构，写功能前先画图，把思路画出来，先完成功能再考虑优化其时间复杂度和空间复杂度！ (致：小菜狗的小林同学！！！)

小林同学7319
关注
  • 19
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构-顺序表的顺序存储
junLe_come_on的博客
11-11 3626
定义： 用一组地址连续的存储单元依次存储线性表中每个数据元素，这种存储结构称为线性表的顺序存储结构，用这种结构表示的线性表称为顺序表。 特点： 用数据元素在计算机内物理位置相邻来表示线性表中数据元素之间的逻辑关系。 存储位置： 线性表中第i个数据元素ai的存储位置 线性表的顺序存储结构为随机存储结构 存储结构内存视图 代码表示： 顺序表的插入 /** *...
JavaScript数据结构-2-顺序表
01-20
 //我又想到JAVA里有构造函数，我设想的js的构造函数应该跟java类似，在构造函数里初始化  //找了半天，没找到，还是慢慢找吧  //卧槽，居然让我百度到了，还是MDN靠谱啊，CSDN和博客园搜索‘构造函数’都没有...
Java数据结构-认识顺序表
weixin_55752048的博客
01-16 1411
目录 二.顺序表 1.概念及结构 2.顺序表的实现 打印顺序表 获取顺序表的有效长度 在pos位置新增元素 判断是否包含某个元素 查找某个元素对应的位置 获取/查找pos位置的元素 给pos位置的元素设为value 删除第一次出现的关键字key 清空顺序表 3.顺序表的优、缺点 三.顺序表的实现代码汇总 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见 的线性表：顺序表、链表、栈、队列、字符串...
《Java数据结构入门》顺序表详解
日常学习记录、分享，愿我们都遇见更好的自己，与诸君共勉
04-25 5532
带你手把手自己模拟实现Java数据结构中的顺序表，很详细的哟😁
【Java 数据结构】顺序表
程序猿教你打篮球的博客
11-01 3719
本期主要讲解： 1、什么是顺序表？ 2、模拟实现ArrayList 2.1 模拟实现前的约定 2.2构造方法 2.3 add方法 2.4 contains 方法 2.5 indexOf 方法 2.6 get 方法 2.7 set 方法 2.8 remove 方法 2.9 getSize 和 clear 方法 3、ArrayList 的学习 3.1 ArrayList的成员属性 3.2 ArrayList的构造方法 4、ArrayList的使用 4.1 ArrayList的遍历 4.2 扑克牌例子
Java数据结构-1 ArrayList顺序表实现
Xucc_x的博客
05-25 2705
1. ArrayList子类   ArrayList是JavaCollection接口下List子接口的实现子类。它是一个长度可变的数组，底层是以数组为基础的顺序表实现的。所以说研究Java顺序表数据结构必须得了解一下ArrayList类。 // ArrayList定义 public class ArrayList&amp;amp;lt;E&amp;amp;gt; extends AbstractList&amp;amp;lt;E&amp;amp;gt...
java数据结构-栈
小赵的呢
02-18 6263
栈 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的常见基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：判断一个栈是否为空，若栈为空则返回t
【数据结构】Java实现顺序表
weixin_64182409的博客
12-19 2371
介绍顺序表，使用Java语言简单模拟实现顺序表
数据结构---Java版
qq_63897791的博客
11-24 2392
🎈数据结构通常有四种基本类型：集合结构，线性结构（一对一），树形结构（一对多），图形结构或网状结构（多对多）；主要描述的三个方面的内容：数据的逻辑结构、物理结构、数据的操作集合。🎈数据的逻辑结构与数据在计算机中的具体存储没有关系，主要包括集合、线性、树形、图形结构，有两个要素，数据结构的集合（D）和D上的关系集（反映了D中元素的前驱后继关系）。🎈数据的物理结构又称存储结构，有顺序和链式两种方式：🎶顺序存储的特点是数据元素在存储器中的相对位置来说体现数据元素的逻辑关系，通常用一维数组来实现。
Java数据结构(线性表)--线性表的顺序存储（顺序表）及其实现
天行健 君子以自强不息，地势坤 君子以厚德载物。
07-04 1432
1. 线性表的顺序存储及其实现 1.1 顺序表的定义 所谓顺序表，就是顺序存储的线性表。顺序存储是用一组地址连续的存储单元依次存放线性表 中的各个数据元素的存储结构
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）
iiiiiihuang的博客
09-03 2452
前言：这篇博客我们重点讲线性表中的顺序表、链表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
数据结构线性表-顺序表（c++、java）.pdf
11-12
顺序表是一种基本的数据结构，它在线性表的基础上采用了顺序存储的方式。在线性表中，元素之间存在一对一的逻辑关系，而顺序表则是将这些逻辑上相邻的元素在内存中也保持相邻，通常通过数组实现。顺序表有静态分配和...
数据结构顺序表-存储学生信息(Java)
03-25
Java顺序表 作用：存储学生信息（学号、姓名、年龄） 类：MyArrayList、Student、Main 方法：增删改查
Java-数据结构课设-链表实现通讯录管理系统
10-07
一、用链表或者顺序表实现以下系统，完成线性表的建立（至少包括10个结点），以及线性表中信息（结点）的插入、查找、删除、修改、输出等操作，具体的模块要求见上方的“总的模块要求”。建议用“文件”存储数据。 1...
配置系统PATH环境变量
weixin_44626980的博客
06-29 561
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
Java面试题:Redis为什么速度快
qq_55630615的博客
06-25 824
因为Redis是纯内存操作,执行速度非常快,性能的瓶颈是网络延迟而非执行速度I/O多路复用模型主要就是实现了高效的网络请求。
【C++】————string基础用法及部分函数底层实现
最新发布
bhbcdxb123的博客
06-30 993
本文主要介绍STL容器之一 ---- string，在学习C++的过程中，我们要将C++视为一个语言联邦（摘录于Effective C++ 条款一）。如何理解这句话呢，我们学习C++，可将其分为四个板块；分别为C、Object-Oriented C++（面向对象的C++）、Template C++（模板）、STL。本文就介绍STL中的string；1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。
基于weixin小程序智慧物业系统的设计
ing65768的博客
06-27 382
管理员账户功能包括：系统首页，个人中心，管理员管理，用户管理，员工管理，房屋管理，缴费管理，车位管理，报修管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。工作人员账号功能包括：系统首页，维修管理，维修指派，公告管理，轮播图信息。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
数据结构顺序表的逆置Java
04-21
很高兴回答你的问题！顺序表的逆置可以通过交换表中元素的位置实现。具体方法如下： 1. 定义两个指针，分别指向顺序表的头尾元素。 2. 交换指针所指位置的元素。 3. 将头指针往后移动一位，尾指针往前移动一位。 4. 重复步骤2和3，直到头指针大于等于尾指针。 在Java中，可以用以下代码实现顺序表的逆置： ``` public void reverse(ArrayList<Integer> list) { int i = 0; int j = list.size() - 1; while (i < j) { int tmp = list.get(i); list.set(i, list.get(j)); list.set(j, tmp); i++; j--; } } ``` 这个函数接受一个ArrayList<Integer>作为参数，将其逆置。通过循环和get和set方法，我们可以实现对各个元素位置的交换。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小林同学7319

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值