Java顺序表

最新推荐文章于 2022-11-01 09:05:15 发布
最新推荐文章于 2022-11-01 09:05:15 发布
阅读量146 收藏
点赞数
分类专栏： JavaSE Java数据结构 文章标签： java 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44721738/article/details/121072265
版权

目录

1.线性表

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

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

2.顺序表

2.1 概念及结构

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

顺序表一般可以分为：

  1. 静态顺序表：使用定长数组存储。
  2. 动态顺序表：使用动态开辟的数组存储。

静态顺序表适用于确定知道需要存多少数据的场景.
静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用

2.2 常见接口

public class MyArrayList {
     // 打印顺序表
     public void display() {   }
     // 在 pos 位置新增元素
     public void add(int pos, int data) { }
     // 判定是否包含某个元素
     public boolean contains(int toFind) { return true; }
     // 查找某个元素对应的位置
     public int search(int toFind) { return -1; }
     // 获取 pos 位置的元素
     public int getPos(int pos) { return -1; }
     // 给 pos 位置的元素设为 value
     public void setPos(int pos, int value) {   }
     //删除第一次出现的关键字key
     public void remove(int toRemove) {   }
     // 获取顺序表长度
     public int size() { return 0; }
     // 清空顺序表
     public void clear() {   }
 }

2.3接口具体实现

首先定义顺序表elem，并用构造函数初始化顺序表，顺序表有效数据个数usedSize

public int[] elem;
    public int usedSize;//0有效数据个数

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

2.3.1打印顺序表

将顺序表中有效个数据打印出来：

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

2.3.2在 pos 位置新增元素

增加元素首先要看元素插入的位置是否合法，其次判断顺序表是否满了，满了要对顺序表进行扩容
将pos位置及后面的元素后移，然后将data插入elem[pos]位置

 //在 pos 位置新增元素
    public void add(int pos, int data) {
        if (pos < 0 || pos > usedSize) {
            System.out.println("位置不合法！");
            return;
        }
        if (isFull()) {
            Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        //3
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

//判断是否满
 public boolean isFull() {
        return this.usedSize == this.elem.length;
    }

2.3.3 判定是否包含某个元素

将元素与顺序表有效数据范围的元素依次进行比较，如果有返回true，否则返回false。

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

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

将元素与顺序表有效数据范围的元素依次进行比较，如果有返回下标i，否则返回-1。

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

2.3.5获取 pos 位置的元素

首先判断pos位置是否合法，其次判断顺序表是否为空
获取pos位置元素，返回

 // 获取 pos 位置的元素
    public int getPos(int pos) {
        if (pos < 0 || pos >= usedSize) {
            System.out.println("pos位置不合法");
            return -1;//说明，业务上的处理，不考考虑
        }
        if (isEmpty()) {
            System.out.println("顺序表为空!");
            return -1;
        }
        return this.elem[pos];
    }

//判空
public boolean isEmpty() {
        return this.usedSize == 0;
    }

2.3.6给 pos 位置的元素设为 value

首先判断pos位置是否合法，其次判断顺序表是否为空
pos位置元素设置为value

 // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {
        if (pos < 0 || pos >= usedSize) {
            System.out.println("pos位置不合法");
            return;//说明，业务上的处理，不考考虑
        }
        if (isEmpty()) {
            System.out.println("顺序表为空!");
            return;
        }
        this.elem[pos] = value;
    }

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

将下标为i的元素删除，将elem[i]值设置为elem[i+1],

//删除第一次出现的关键字key
    //1.判断顺序表是否为空
    //2.查找要删除的数字elem[i]==toRemove
    //3.i<usedSize-1,将elem[i+1]=elem[i]
    public void remove(int toRemove) {
        if (isEmpty()) {
            System.out.println("顺序表为空！");
            return;
        }
        int index = search(toRemove);
        if (index == -1) {
            System.out.println("没有你要删除的数字！");
        }
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        this.usedSize--;
        //this.elem[usedSize]==null;如果数组是引用数据类型
    }

2.3.8 获取顺序表的有效数据长度

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

2.3.9 清空顺序表

 // 清空顺序表
    public void clear() {
        this.usedSize=0;

        /*
         * @Description:引用数据类型
         * @param
         */
        /*for (int i = 0; i <usedSize ; i++) {
            this.elem[i]=null;
        }
        this.usedSize=0;
        */
    }

3完整代码

import java.util.Arrays;

/**
 * Created with IntelliJ IDEA
 * Description:
 * User: 23006
 * Date: 2021-10-31
 * Time: 10:29
 * main: psvm
 * 打印: sout
 */
public class MyArrayList {
    public int[] elem;
    public int usedSize;//0有效数据个数

    public MyArrayList() {
        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();
    }

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

    //在 pos 位置新增元素
    public void add(int pos, int data) {
        if (pos < 0 || pos > usedSize) {
            System.out.println("位置不合法！");
            return;
        }
        if (isFull()) {
            Arrays.copyOf(this.elem, 2 * this.elem.length);
        }
        //3
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }

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

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

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

    // 获取 pos 位置的元素
    public int getPos(int pos) {
        if (pos < 0 || pos >= usedSize) {
            System.out.println("pos位置不合法");
            return -1;//说明，业务上的处理，不考考虑
        }
        if (isEmpty()) {
            System.out.println("顺序表为空!");
            return -1;
        }
        return this.elem[pos];
    }

    public boolean isEmpty() {
        return this.usedSize == 0;
    }

    // 给 pos 位置的元素设为 value
    public void setPos(int pos, int value) {
        if (pos < 0 || pos >= usedSize) {
            System.out.println("pos位置不合法");
            return;//说明，业务上的处理，不考考虑
        }
        if (isEmpty()) {
            System.out.println("顺序表为空!");
            return;
        }
        this.elem[pos] = value;
    }

    //删除第一次出现的关键字key
    //1.判断顺序表是否为空
    //2.查找要删除的数字elem[i]==toRemove
    //3.i<usedSize-1,将elem[i+1]=elem[i]
    public void remove(int toRemove) {
        if (isEmpty()) {
            System.out.println("顺序表为空！");
            return;
        }
        int index = search(toRemove);
        if (index == -1) {
            System.out.println("没有你要删除的数字！");
        }
        for (int i = index; i < this.usedSize - 1; i++) {
            this.elem[i] = this.elem[i + 1];
        }
        this.usedSize--;
        //this.elem[usedSize]==null;如果数组是引用数据类型
    }

    // 清空顺序表
    public void clear() {
        this.usedSize=0;

        /*
         * @Description:引用数据类型
         * @param
         */
        /*for (int i = 0; i <usedSize ; i++) {
            this.elem[i]=null;
        }
        this.usedSize=0;
        */
    }
}

public class Test {
    public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(0,1);
        myArrayList.add(1,2);
        myArrayList.add(2,3);
        myArrayList.add(3,4);
        myArrayList.add(4,5);
        myArrayList.display();
        System.out.println(myArrayList.contains(3));
        System.out.println(myArrayList.search(1));
        System.out.println(myArrayList.getPos(4));
        myArrayList.setPos(4,78);
        myArrayList.display();
        myArrayList.clear();
        myArrayList.display();
    }
}

在这里插入图片描述

棕旨2434
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java顺序表基本操作
04-02
java顺序表的基本操作
java顺序表的基本操作.docx
09-27
下面是对Java顺序表的基本操作进行详细的介绍。 创建顺序表： 首先需要定义一个包含元素的数组，用于存储顺序表中的数据。 可以选择使用数组的静态初始化或动态初始化来创建顺序表。 可以定义一个变量来记录顺序表...
java顺序表
Nakahara_Chuya的博客
03-05 217
线性表 线性表： 线性表（linear list） 是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构。线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储 时，通常以数组和链式结构的形式存储。 常见的线性表： 顺序表、链表、栈、队列、字符串… 顺序表 顺序表： 基于数组来实现 顺序表的属性： usedSize、数组...
java顺序表实验报告.docx
10-11
数据结构顺序表实验报告
java顺序表的基本操作.zip
12-17
java顺序表的基本操作
顺序表java实现
09-30
对于数据结构中顺序表的实现，建立了一个接口、两个类。通过在类中调用，实现顺序表功能。
JAVA顺序表
qq_59539549的博客
11-28 639
目录 一、深浅拷贝 二、DateTime类整合 三、复杂度（complexity） 四、顺序表 一、深浅拷贝 1.如何对DateTime对象进行复制 DateTime source=new DateTime（...）； 方法一：DateTime dest=source分析：完全不可以实现，仅仅创建新的引用dest指向source 方法二：DateTime dest=source.copy(); ...
Java--顺序表
sunjiac的博客
10-30 309
线性表 线性表：是具有n个相同特性的数据元素的有限序列。 常见的线性表：顺序表，链表，栈，队列，字符串。 顺序表 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。 顺序表分为： 1.静态顺序表：使用定长数组储存。 2.动态顺序表：使用动态开辟的数组储存。 适用不同场景： 静态顺序表适用于确定知道需要存多少数据的场景. 静态顺序表的定长数组导致N定大了，空间开...
Java_顺序表
weixin_41552254的博客
09-24 135
SeqList.java public class SeqList{ private int[] data = new int[10]; private int size = 0; //扩容 private void realloc(){ int[] newData = new int[this.da...
顺序表（Java语言）
qq_57563254的博客
11-17 2346
顺序表和列表（Java语言）前言线性表顺序表概念及结构 前言 当我们接触到顺序表与列表时，就涉及到了数据结构的知识，顺序表和列表是数据结构最为基础的部分，所谓数据结构就是存储数据的方式，有同学会问C语言数据结构和Java语言数据结构有什么不同？其实没有不同，数据结构是一门单独的学科，就好比C语言是中文，Java是英文，数据结构是数学，我们可以用英文表达数学的逻辑结构，也可以用中文表达数学的逻辑结构，所以数据结构也是如此。 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性
顺序表--Java版
迷路的小绅士之家
03-03 598
顺序表是一种基本的线性表结构，它通过数组来实现，支持快速随机访问元素，可以进行插入、删除操作。在实际应用中，顺序表被广泛地应用于常规数据结构、数据库系统以及算法设计等领域。在实现顺序表时，需要注意容量的扩展、元素的移动等问题，同时需要处理越界异常。
【Java 数据结构】顺序表
程序猿教你打篮球的博客
11-01 3690
本期主要讲解： 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版）
梦之马
10-29 937
要点： 顺序表：采用顺序存储结构的线性表 顺序存储结构和链式存储结构不同，强调的是存储元素在物理地址存储的上连续！可实现随机存取（只要知道第一个元素的内存地址，再通过简单的加减就能找到任意一个元素了） 顺序表耗时在对移动元素上，进行插入、删除时都需要移动元素本人做顺序表的难点主要在于对顺序表进行插入时，需要多一个存储位，同时又要保存原来的数据 ，详情请看2的insert(int i, Ob
java顺序表binsert
最新发布
03-20
Java顺序表是一种线性数据结构，它按照元素在内存中的顺序存储数据。顺序表的插入操作是将一个元素插入到指定位置，而不改变其他元素的位置。binsert是一种二分插入排序算法，用于在有序的顺序表中插入一个元素。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值