1. Toy模板网首页
  2. > Toy博客

《Java数据结构入门》顺序表详解

10月前 作者：是小鱼儿哈 分类：Toy博客 阅读(33) 违法举报

这篇具有很好参考价值的文章主要介绍了《Java数据结构入门》顺序表详解。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

《Java数据结构入门》顺序表详解

 大家好，我是小鱼儿

目录

顺序表介绍：

顺序表的手动实现

顺序表功能接口概览

基本功能的实现

四大功能

一、增加数据 

二、删除数据

三、查找数据

四、修改数据

 总代码

MyArraysList.java

 Test.java

顺序表介绍：

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

🍑顺序表一般可以分为：

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

顺序表的手动实现

📝本文将创建两个Java文件：MyArraysList.java用于顺序表的实现，Test.java用于顺序表的各个接口的测试

顺序表功能接口概览

import java.util.Arrays;

public class MyArraysList {
    private int[] elem;
    private int usedSize; // 默认值是0
    private static final int DEFAULT_SIZE = 4; // 定义为常量，更加安全

    // 初始化顺序表
    public MyArraysList() {
        this.elem = new int[4];
    }
    // 对顺序表进行扩容
    public void expand() {}

    //判断当前顺序表是否为空
    public boolean isempty() {}

    // 判断当前顺序表是不是满了
    public boolean isFull() {}

    // 打印顺序表
    public void display() {}


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

    // 新增元素，在数组最前面新增
    public void addHead(int data){}

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


    // 删除表头元素
    public void removeHead() {}

    // 删除表尾元素
    public void removeTail() {}

    // 指定下标元素的删除
    public void removePos(int pos) {}

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


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

    // 查找某个元素对应的位置
    public int indexOf(int toFind) { return -1; }
    
    // 获取 pos 位置的元素
    public int getPos(int pos) { return -1; }
    
    // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {}
    
    // 获取顺序表长度
    public int size() { return 0; }
    
    // 清空顺序表
    public void clear() {}
}

基本功能的实现

🌰对顺序表进行扩容

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

 

🌰判断顺序表是否为空 

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

 

🌰判断顺序表是否已满

    /**
     * 判断当前顺序表是不是满了
     * @return true->满了，false->还没满
     */
    public boolean isFull() {
        if (this.usedSize == this.elem.length) return true;
        else return false;
    }

🌰打印顺序表

// 打印顺序表
// 打印的第一种方式
    public void display() {
        for (int i = 0; i < this.elem.length; 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] = 0;
        }
        this.usedSize = 0; // 注意有效数组长度也要清零
    }

四大功能

一、增加数据 

🌰头插

 // 新增元素，在数组最前面新增
    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 addTail(int data) {
        if (isFull()) {
            System.out.println("数组满了需要扩容");
            expand();
        }
        else this.elem[this.usedSize++] = data;
    }

🌰指定下标插入 

  1.  判断pos位置是否合法（在顺序表中，数据是连续的，中间不能有空缺）
  2.  判断顺序表是否满了，如果满了，需要扩容
  3.  插入数据（可能需要挪动元素）
// 在 pos 位置新增元素
    public void addPos(int pos, int data) {
        if (pos < 0 || pos > usedSize) {
            System.out.println("pos位置不合法"); return;
        }
        if (isFull()) {
            System.out.println("数组满了需要扩容");
            expand();
        }
        else {
            // 如果插入位置在顺序表的中间，要注意挪动元素，从后向前挪动，这样不会造成元素值的覆盖
            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;
        }
        if (pos < 0 || pos >= this.usedSize) {
            System.out.println("pos下标不合法");
        }
        else {
            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 removeKey(int toRemove) {
        if (isempty()) {
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toRemove) {
                // 注意是this.usedSize - 1，将此时 i 之后的元素统一往前搬移一个位置
                for (int j = i; j < this.usedSize - 1; ++j) {
                    this.elem[j] = this.elem[j + 1];
                }
                this.elem[this.usedSize - 1] = 0; // 要完整的删除，将挪动的最后一个元素的原本位置 置空
                this.usedSize--; // 删除后不要忘记更改顺序表的有效长度
                return; // 只删除第一次出现的
            }
        }
    }

三、查找数据

🌰获取指定位置的元素

  1. 考虑要获取的位置是否合法
  2. 返回指定位置的元素
 // 获取 pos 位置的元素
    public int getPos(int pos) {
        if (pos < 0 || pos >= this.usedSize) { // 注意这里当pos==this.usedSize也是不合法的，因为此时的pos下标所要获取的是顺序表中第usedSize+1个元素
            System.out.println("pos的位置不合法");
            return -1;
        }
        else {
            return this.elem[pos];
        }
    }

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

 // 查找某个元素所对应顺序表中的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toFind) {
                return i;
            }
        }
        System.out.println("在数组中没有找到该元素");
        return -1;
    }

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

 /**
 * /判定是否包含某个元素
 * @param toFind 要查找的元素
 * @return true->包含， false->不包含
 */
    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 setPos(int pos, int value) {
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法");
            return;
        }
        if (pos == this.usedSize) { // 对这种情况要单独处理，此时相等于增加元素
            this.elem[pos] = value;
            this.usedSize++;
        }
        else {
            this.elem[pos] = value;
        }

    }

 总代码

📝MyArraysList.java

import java.util.Arrays;

public class MyArraysList {
    private int[] elem;
    private int usedSize; // 默认值是0
    private static final int DEFAULT_SIZE = 4; // 定义为常量，更加安全
    // 初始化顺序表
    public MyArraysList() {
        this.elem = new int[4];
    }
    // 对顺序表进行扩容
    public void expand() {
        this.elem = Arrays.copyOf(this.elem, this.usedSize * 2);
        System.out.println("已经成功扩容至原来的两倍"); // 给用户提醒
    }

    /**
     * 判断当前顺序表是否为空
     * @return true->空的，false->还没空
     */
    public boolean isempty() {
        if (this.usedSize == 0) {
            return true;
        }
        else return false;
    }
    /**
     * 判断当前顺序表是不是满了
     * @return true->满了，false->还没满
     */
    public boolean isFull() {
        if (this.usedSize == this.elem.length) return true;
        else return false;
    }
    // 打印顺序表
    public void display() {
        for (int i = 0; i < this.elem.length; i++) {
            System.out.print(this.elem[i] + " ");
        }
        // System.out.println(Arrays.toString(this.elem));或者用Arrays.toString打印也行
        System.out.println();
    }

    // 新增元素,默认在数组最后新增
    public void addTail(int data) {
        if (isFull()) {
            System.out.println("数组满了需要扩容");
            expand();
        }
        else this.elem[this.usedSize++] = data;
    }
    // 新增元素，在数组最前面新增
    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++;    // 数组有效长度加一
        }
    }
    // 1、判断pos位置是否合法（在顺序表中，数据是连续的，中间不能有空缺）
    // 2、判断顺序表是否满了，如果满了，需要扩容
    // 3、插入数据（可能需要挪作元素）
    // 在 pos 位置新增元素
    public void addPos(int pos, int data) {
        if (pos < 0 || pos > usedSize) {
            System.out.println("pos位置不合法"); return;
        }
        if (isFull()) {
            System.out.println("数组满了需要扩容");
            expand();
        }
        else {
            // 如果插入位置在顺序表的中间，要注意挪动元素，从后向前挪动，这样不会造成元素值的覆盖
            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;
        }
        if (pos < 0 || pos >= this.usedSize) {
            System.out.println("pos下标不合法");
        }
        else {
            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 removeKey(int toRemove) {
        if (isempty()) {
            System.out.println("顺序表为空，删除不合法");
            return;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i] == toRemove) {
                // 注意是this.usedSize - 1，将此时 i 之后的元素统一往前搬移一个位置
                for (int j = i; j < this.usedSize - 1; ++j) {
                    this.elem[j] = this.elem[j + 1];
                }
                this.elem[this.usedSize - 1] = 0; // 要完整的删除，将挪动的最后一个元素的原本位置 置空
                this.usedSize--; // 删除后不要忘记更改顺序表的有效长度
                return; // 只删除第一次出现的
            }
        }
    }

    /**
     * /判定是否包含某个元素
     * @param toFind 要查找的元素
     * @return true->包含， false->不包含
     */
    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;
            }
        }
        System.out.println("在数组中没有找到该元素");
        return -1;
    }
    // 获取 pos 位置的元素
    public int getPos(int pos) {
        if (pos < 0 || pos >= this.usedSize) {
            System.out.println("pos的位置不合法");
            return -1;
        }
        else {
            return this.elem[pos];
        }
    }
    // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {
        if (pos < 0 || pos > this.usedSize) {
            System.out.println("pos位置不合法");
            return;
        }
        if (pos == this.usedSize) { // 对这种情况要单独处理，此时相等于增加元素
            this.elem[pos] = value;
            this.usedSize++;
        }
        else {
            this.elem[pos] = value;
        }

    }

    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }
    // 清空顺序表
    public void clear() {
        for (int i = 0; i < this.usedSize; i++) {
            this.elem[i] = 0;
        }
        this.usedSize = 0; // 注意有效数组长度也要清零
    }

}

 📝Test.java

🏀对顺序表进行 测试的代码：

/**
 * 对顺序表进行测试的代码
 */
public class Test {
    public static void main(String[] args) {
        MyArraysList myArraysList = new MyArraysList();
        // 尾插四个数字
        myArraysList.addTail(12);
        myArraysList.addTail(32);
        myArraysList.addTail(17);
        myArraysList.addTail(32);
        // 进行扩容
        myArraysList.expand();
        // 指定在pos位置新增元素
        myArraysList.addPos(1, 777);
        // 打印当前的顺序表
        System.out.print("第一次测试的顺序表为：");
        myArraysList.display();

        // 删除顺序表中首次出现的元素32
        myArraysList.removeKey(32);
        // 获取顺序表中 1下标的元素值
        int tmp = myArraysList.getPos(1);
        System.out.println("顺序表中下标为1的元素的值为：" + tmp);
        // 给顺序表中1下标的元素设为value
        myArraysList.setPos(1, 100);
        // 打印此时的顺序表
        System.out.print("修改后第二次测试的顺序表为："); // 此时1下标的值为100
        myArraysList.display();

        // 顺序表此时的有效长度
        System.out.println("顺序表的有效长度为：" + myArraysList.size());
        // 清空顺序表
        myArraysList.clear();
        System.out.print("第三次测试的顺序表为：");
        myArraysList.display();
        System.out.println("清空顺序表后，顺序表的有效长度为：" + myArraysList.size());

    }

}

🏀测试结果

《Java数据结构入门》顺序表详解

 好了，今天的文章就到这里了，感谢大家的支持🥰，下篇见😁

《Java数据结构入门》顺序表详解文章来源地址https://www.toymoban.com/news/detail-416895.html

到了这里，关于《Java数据结构入门》顺序表详解的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 【数据结构】——顺序表详解

    【数据结构】——顺序表详解

    大家好！当我们学习了动态内存管理后，就可以写一个管理数据的顺序表了！！！ 顺序表的理解： 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 顺序表是在计算机内存

    2024年02月08日
    浏览(50)
  • 数据结构：顺序表详解

    数据结构：顺序表详解

    线性表（linear list）是n个具有 相同特性的数据元素的有限序列 。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是 在物理结构上并不一定是连续的 。 线性表在物理

    2024年02月14日
    浏览(35)
  • 【数据结构】顺序表详解

    【数据结构】顺序表详解

    当我们写完通讯录后，顺序表肯定难不倒你，跟着小张一起来学习顺序表吧！ 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就

    2024年02月10日
    浏览(47)
  • 数据结构（一）：顺序表详解

    数据结构（一）：顺序表详解

    在正式介绍顺序表之前，我们有必要先了解一个名词：线性表。 线性表： 线性表是，具有n个相同特性的数据元素的有限序列。常见的线性表：顺序表、链表、栈、队列、数组、字符串... 线性表在逻辑上是线性结构，但在物理结构上并不一定是连续的。 1. 顺序表概念 顺序表

    2024年02月13日
    浏览(40)
  • 数据结构之顺序表详解

    数据结构之顺序表详解

    hello，大家好，今天的内容是关于顺序表的，其实之前也发过文章，但是那个时候水平还是差了一点，有些地方不是很详细，这次会把每个点都讲清楚，也当给自己在复习一遍。 顺序表在本质上就是数组，顺序表是连续的，我们的数组在内存上也是连续存储的，所以我们可以

    2024年02月06日
    浏览(41)
  • 【数据结构】 顺序表详解！(源码+解析)

    【数据结构】 顺序表详解！(源码+解析)

    🎥 屿小夏 ： 个人主页 🔥个人专栏 ： 数据结构解析 🌄 莫道桑榆晚，为霞尚满天！ ​ 什么是数据结构？我们为什么要学数据结构？数据结构中的顺序表长什么样子？它是怎么运用？ ​ 本期我们将对这些一一讲解,彻底明白数据结构的重要性，以及顺序表是一种什么的数据

    2024年02月06日
    浏览(46)
  • 【数据结构】 顺序表详解！深入理解！

    【数据结构】 顺序表详解！深入理解！

    🎥 屿小夏 ： 个人主页 🔥个人专栏 ： 数据结构解析 🌄 莫道桑榆晚，为霞尚满天！ ​ 什么是数据结构？我们为什么要学数据结构？数据结构中的顺序表长什么样子？它是怎么运用？ ​ 本期我们将对这些一一讲解,彻底明白数据结构的重要性，以及顺序表是一种什么的数据

    2024年02月08日
    浏览(42)
  • 数据结构：详解【顺序表】的实现

    数据结构：详解【顺序表】的实现

    顺序表是用一段 物理地址连续 的存储单元 依次存储数据元素 的线性结构，一般情况下采用数组存储。动态顺序表与数组的本质区别是—— 根据需要动态的开辟空间大小。 动态顺序表的功能一般有如下几个： 初始化顺序表 打印顺序表中的数据 检查顺序表的容量 顺序表头部

    2024年03月14日
    浏览(58)
  • 数据结构（C语言）——顺序表详解

    数据结构（C语言）——顺序表详解

    数据结构是计算机存储和组织数据的方式。常用的数据结构有：数组（Array）、栈（Stack）、队列（Queue）、链表（Linked List）、树（Tree）、图（Graph）、堆（Heap）等；而数据结构又可以通过逻辑结构与物理结构进行分类，逻辑结构是指数据元素之间的逻辑关系，也就是数据元

    2024年04月16日
    浏览(40)
  • 数据结构学习分享之顺序表详解

    数据结构学习分享之顺序表详解

    在前一个章节中我们介绍到, 数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。 那么具体有哪些结构是我们常常用来存储数据的呢?今天就给大家讲解其中的一个结构: 顺序表, 本篇文章将收录于数据结构学习分享专

    2024年02月05日
    浏览(50)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包