【DS】Java实现顺序表

已于 2023-03-18 21:01:21 修改
阅读量428 收藏 5
点赞数 6
分类专栏： Java - 数据结构 文章标签： java 算法 数据结构 链表 Powered by 金山文档
于 2023-02-07 20:24:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56952690/article/details/128925247
版权

1.线性表中的顺序表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列...

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

2.顺序表

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

2.1接口的整体实现

public class SeqList {
// 打印顺序表
public void display() { }
// 新增元素,默认在数组最后新增
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() { }
}

2.2顺序表的定义

顺序表本质上是基于数组进行操作的, 所以顺序表成员中定义一个数组elem来存放数据, 这里的顺序表实现以整形为例, 顺序表中的元素可以是其他类型,实现方法类似。定义变量usedSize用来记录顺序表中的元素个数; 定义常量并给出构造方法以方便在创建顺序表时给数组分配默认空间。

public class MyArrayList {
    private int[] elem;//数组
    private int usedSize;//记录有效数据个数
    private static final int SIZE = 10;
    
    //构造方法
    public MyArrayList() {
        this.elem = new int[SIZE];
    }
}

2.3新增元素,默认在数组最后新增

  1. 首先要判断该表如果为空符合条件吗，很显然是可以的。

  1. 判断该表是否满了，因为顺序表实际上是数组，是有大小的，如果超出，则需要进行扩容，这里我们进行的是手动二倍扩容（采用的是Arrays.copyOf，将扩容后的拷贝到当前的）。

  1. 确定该表满了的条件，当数组的长度等于当前表的长度时，进行判满扩容。

  1. 对下标为usedSize的数组进行赋值data操作

public void add(int data) {
        if(isFull()){
            System.out.println("满了");
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }
    public boolean isFull(){
        if (this.elem.length == this.size()){
            return true;
        }
        return false;
    }

2.4在 pos 位置新增元素

  1. 判断条件（此时的表是否已经满了，空的话不影响，然后就是pos位置是否合法，pos<0或者pos>size（）不合法则抛出异常）。

  1. 从后往前开始遍历，依次往前覆盖（i-1）= i，例如从2号位置开始插入，则0 1 2 3 4 覆盖后为 0 1 2 2 3 4，再将2号位置改为需要插入元素的值。

public void add(int pos, int data) throws PosWrongfulException{
        if(isFull()){
            System.out.println("满了");
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        if(pos < 0 || pos > this.usedSize){
            throw new PosWrongfulException("pos不合法");
        }
        //pos合法，从pos位置开始所有元素往后挪一次
        for (int i = this.usedSize; i > pos; i--) {
            this.elem[i] = this.elem[i-1];
        }
        //将pos位置更为插入数据
        this.elem[pos] = data;
        //更新新的数据个数
        this.usedSize++;
    }
    public boolean isFull(){
        if (this.elem.length == this.size()){
            return true;
        }
        return false;
    }

2.5判定是否包含某个元素

遍历该数组即可。

public boolean contains(int toFind) {
        for (int i = 0; i < this.size(); i++) {
            if (this.elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

2.6查找某个元素对应的位置

遍历该数组即可。

public int indexOf(int toFind) {
        for (int i = 0; i < this.size(); i++) {
            if (this.elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }

2.7获取 pos 位置的元素

1.如果顺序表中没有存放元素的话是不能去获取元素的, 这里同样可以去声明一个异常去解决问题。

2.同时要判断位置的合法性（注意这次pos位置的区间，和前面的区别）。

3.上面两个条件都没问题的话就可以通过下标去获取元素了。

public int get(int pos) throws PosWrongfulException,EmptyException{
        if(isEmpty()){
            throw new EmptyException("空异常了");
        }
        if(pos < 0 || pos >= this.usedSize){
            throw new PosWrongfulException("pos不合法");
        }
        return this.elem[pos];
    }
    public boolean isEmpty(){
        return this.size()==0;
    }

2.8给 pos 位置的元素设为 value

同2.7。

public void set(int pos, int value) throws PosWrongfulException,EmptyException{
        if(isEmpty()){
            throw new EmptyException("空异常了");
        }
        if(pos < 0 || pos >= this.usedSize){
            throw new PosWrongfulException("pos不合法");
        }
        this.elem[pos] = value;
    }

2.9删除第一次出现的关键字key

1.判断顺序表是否为空。

2.不为空则先找到要删除元素的位置,可参考2.6。

3.将key之后的元素逐一往前覆盖, 将key覆盖便达到了删除的效果。

4.最后要记得元素的有效个数要减1。

5.需要注意的是,这里删除的基本数据类型的数据, 删除后相对于删除前数组的最后一个位置, 虽然那个位置还留有原来的值, 但这个值不置为0并不会有什么影响;而如果顺序表中放置的是引用类型, 此时这个位置必须置空(置为null), 否则会有内存泄漏的问题存在

public void remove(int toRemove) {
        if(isEmpty()){
            throw new EmptyException("空异常了");
        }
        //查找要删除元素的位置，参考2.6
        int r = this.indexOf(toRemove);
        if(r == -1) {
            System.out.println("没有这个数字");
            return;
        }
        //删除元素，从后往前进行覆盖
        for (int i = r; i < this.usedSize-1; i++) {
            this.elem[i] = this.elem[i+1];
        }
        //更新有效数据个数
        this.usedSize--;
    }

2.10获取顺序表长度

获取顺序表中记录数组中有效数据个数的成员即可。

public int size() {
        return this.usedSize;
    }

2.11清空顺序表

将数组的有效元素个数赋值为0即可;同样的, 要注意如果顺序表中的元素是引用类型的话, 要将数组中的每个元素都置为null。

public void clear() {
        this.usedSize = 0;
        System.out.println("顺序表也已经清空");
    }

2.12打印顺序表

遍历数组打印即可。

public void display() {
        for (int i = 0; i < this.size(); i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println();
    }

3.顺序表的全局实现

3.1 EmptyException.java(空指针异常)

public class EmptyException extends RuntimeException{
    public EmptyException() {
    }
    public EmptyException(String message) {
        super(message);
    }
}

3.2 PosWrongfulException.java(越界异常)

public class PosWrongfulException extends RuntimeException{
    public PosWrongfulException() {
    }
    public PosWrongfulException(String message) {
        super(message);
    }
}

3.3 MyArrayLisst.java

import java.util.Arrays;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:YY
 * Date:2023-02-09
 * Time:19:52
 */
public class MyArrayList  {
    public int[] elem;
    public int usedSize;
    private static final int SIZE = 10;

    public MyArrayList() {
        this.elem = new int[SIZE];
    }

    public void display() {
        for (int i = 0; i < this.size(); i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println();
    }
    // 新增元素,默认在数组最后新增
    public void add(int data) {
        if(isFull()){
            System.out.println("满了");
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
    }
    public boolean isFull(){
        if (this.elem.length == this.size()){
            return true;
        }
        return false;
    }
    // 在 pos 位置新增元素
    public void add(int pos, int data) throws PosWrongfulException{
        if(isFull()){
            System.out.println("满了");
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        if(pos < 0 || pos > this.usedSize){
            throw new PosWrongfulException("pos不合法");
        }
        //pos合法，从pos位置开始所有元素往后挪一次
        for (int i = this.usedSize; i > pos; i--) {
            this.elem[i] = this.elem[i-1];
        }
        //将pos位置更为插入数据
        this.elem[pos] = data;
        //更新新的数据个数
        this.usedSize++;
    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        for (int i = 0; i < this.size(); i++) {
            if (this.elem[i] == toFind){
                return true;
            }
        }
        return false;
    }
    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        for (int i = 0; i < this.size(); i++) {
            if (this.elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }
    // 获取 pos 位置的元素
    public int get(int pos) throws PosWrongfulException,EmptyException{
        if(isEmpty()){
            throw new EmptyException("空异常了");
        }
        if(pos < 0 || pos >= this.usedSize){
            throw new PosWrongfulException("pos不合法");
        }
        return this.elem[pos];
    }
    public boolean isEmpty(){
        return this.size()==0;
    }
    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) throws PosWrongfulException,EmptyException{
        if(isEmpty()){
            throw new EmptyException("空异常了");
        }
        if(pos < 0 || pos >= this.usedSize){
            throw new PosWrongfulException("pos不合法");
        }
        this.elem[pos] = value;
    }
    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        if(isEmpty()){
            throw new EmptyException("空异常了");
        }
        int r = this.indexOf(toRemove);
        if(r == -1) {
            System.out.println("没有这个数字");
            return;
        }
        for (int i = r; i < this.usedSize-1; i++) {
            this.elem[i] = this.elem[i+1];
        }
        this.usedSize--;
    }
    // 获取顺序表长度
    public int size() {
        return this.usedSize;
    }
    // 清空顺序表
    public void clear() {
        this.usedSize = 0;
        System.out.println("顺序表也已经清空");
    }
}

3.4 TestList.java(测试部分)

import javafx.geometry.Pos;
/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:YY
 * Date:2023-02-09
 * Time:19:51
 */
public class TestList {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(5);
        myArrayList.add(3);
        myArrayList.add(4);
        myArrayList.add(1);
        myArrayList.display();
        System.out.println("-----------------------------");
        try{
            myArrayList.add(1,2);
        }catch (PosWrongfulException e){
            e.printStackTrace();
        }
        System.out.println(myArrayList.size());
        myArrayList.display();
        System.out.println("---------------------");
        System.out.println(myArrayList.contains(2));
        System.out.println(myArrayList.contains(10));
        System.out.println(myArrayList.indexOf(3));
        System.out.println(myArrayList.indexOf(100));
        System.out.println("----------------------------");
        try {
            System.out.println(myArrayList.get(4));
        }catch (PosWrongfulException e) {
            e.printStackTrace();
        }
        myArrayList.set(4,99);
        myArrayList.display();
        System.out.println("==========================");
        myArrayList.remove(3);
        myArrayList.display();
        System.out.println("==========================");

        myArrayList.clear();
        myArrayList.display();

        myArrayList.add(4);
        myArrayList.add(1);
        myArrayList.display();



    }
   /** public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add(2);
        myArrayList.add(3);
        myArrayList.display();
        try {
            myArrayList.add(1,10);
        }catch (PosWrongfulException e) {
            e.printStackTrace();
        }
        myArrayList.display();
        System.out.println("==========================");
        System.out.println(myArrayList.contains(10));
        System.out.println(myArrayList.contains(100));
        System.out.println(myArrayList.indexOf(10));
        System.out.println(myArrayList.indexOf(100));
        System.out.println("==========================");

        try {
            System.out.println(myArrayList.get(1));
        }catch (PosWrongfulException e) {
            e.printStackTrace();
        }

        myArrayList.set(0,99);
        myArrayList.display();
        System.out.println("==========================");

        myArrayList.remove(10);
        myArrayList.display();
        System.out.println("==========================");

        myArrayList.clear();
        myArrayList.display();

        myArrayList.add(19999);
        myArrayList.display();
    }*/
}

3.5 测试结果

苏黎世卡
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
DS-Algo:数据结构和算法的实现
04-19
本项目"DS-Algo"专注于使用Java语言来实现各种经典的数据结构和算法，为学习者提供了一个实际操作的平台。 一、数据结构篇 数据结构是组织和存储数据的方式，它直接影响到算法的效率和程序的性能。"DS-Algo"涵盖的...
DS_ALGO
03-10
Java的`java.util.HashMap`和`java.util.LinkedHashMap`是常用的哈希表实现。哈希表在缓存、查找算法中广泛应用。 7. **树**：分层数据结构，如二叉树、二叉搜索树、平衡树（AVL、红黑树）等。Java中的`java.util....
Java顺序表
x2656271356的博客
07-03 865
Java顺序表
【数据结构】Java实现顺序表
weixin_64182409的博客
12-19 2384
介绍顺序表，使用Java语言简单模拟实现顺序表
Java顺序表的实现
m0_64318128的博客
09-23 1620
Java顺序表中一些常用方法的实现
Java实现顺序表
weixin_64448174的博客
05-12 6015
目录 一、顺序表的简单理解 1、为什么我们要以数组为基础来构建顺序表呢？ 2、顺序表都具有哪些功能 二、顺序表的代码实现 1、构建并且初始化顺序表 2、在顺序表中添加元素 1、判断需要添加元素的下标是否在顺序表的范围内 2、如果添加元素下标合法，进行添加元素操作。 3、判断顺序表是否满了满了的话我们需要进行扩容 4、实现代码如下： 3、打印顺序表中的元素 4、判断顺序表中是否含有某个元素 5、查找顺序表中元素的下标 6、更新顺序表对应下标的元素值 7、查找顺序表对应下标的元
DS_Algo
03-16
7. 哈希表：通过键值对进行快速查找，基于散列函数实现，如Java的HashMap。 算法则是解决问题或执行任务的明确步骤。常见的算法有： 1. 排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序等，...
basic_ds:基本数据结构
07-08
6. **映射/哈希表**：HashMap是基于哈希表实现的，提供快速的查找、插入和删除操作。它通过键的哈希码来定位元素，查找时间复杂度为O(1)。在Java中，Map接口还有其他实现，如TreeMap，它按照键的自然顺序或自定义...
ds-graph
03-20
"ds-graph"是一个与数据结构和图形算法相关的项目，很可能是一个用Java编写的库或学习资源。在Java中，数据结构和图形算法是计算机科学的重要组成部分，它们在解决复杂问题和设计高效系统时起着至关重要的作用。在这...
顺序表java实现
09-30
对于数据结构中顺序表的实现，建立了一个接口、两个类。通过在类中调用，实现顺序表功能。
java实现的顺序表数据结构
04-06
本人也在学习当中，今天只编写了一点，后面我会陆续把对应某种数据结构的算法一一实现上传。编写的不好，请大家批评指教！
java中顺序表的操作
12-22
java中顺序表的操作，实现顺序表的初始化，插入，删除，查找，添加等操作。
【数据结构】静态、动态顺序表
cottonrose_orange的博客
09-11 546
静态顺序表 顺序表的初始化和销毁 打印顺序表 查找 二分查找 增加数据 尾插 头插 在指定位置插入 删除数据 尾删 头删 指定位置删除（下标删除） 指定元素删除（数据删除） 删除所有指定元素 顺序表属性 排序 冒泡排序 选择排序 动态顺序表 顺序表的初始化和销毁 顺序表的打印 增加数据 静态与动态的比较 静态顺序表 数据类型的定义 ...
【数据结构趣味多】顺序表基本操作实现（Java）
努力
12-02 1953
用java对顺序表的实现
Java数据结构之顺序表
qq15035899256的博客
07-02 929
本文介绍了Java数据结构的顺序表的实现原理，教你手写一个顺序表。学懂了这个自然也会掌握ArrayList的用法。之后的学习内容将持续更新！！！
DS顺序表--连续操作
最新发布
09-14
DS顺序表（也称为数组）是一种线性数据结构，它使用连续的存储空间来存储元素。我可以告诉你如何进行一些常见的操作，例如插入、删除和访问元素。 1. 插入元素： 要在顺序表中插入元素，首先需要确定插入的位置。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

苏黎世卡

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

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

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

打赏作者

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

抵扣说明：

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

余额充值