［JavaDS］顺序表

最新推荐文章于 2024-05-15 17:22:30 发布
最新推荐文章于 2024-05-15 17:22:30 发布
阅读量422 收藏
点赞数 1
分类专栏： 数据结构/算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42645168/article/details/90143108
版权

目录

 

线性表

顺序表

１属性

２方法

 2.1public boolean add(int pos, Object data)//在pos位置插入data

 2.2public int search(int key)//查找关键字key位置的数组下标

2. 3  public boolean contains(Object key)//判断是否包含关键词key是否在顺序表当中

2.4 public Object getPos(int pos)  //得到pos的值

2.5  public Object remove(Object key)  //删除第一次出现的关键字key

 2.6 public int size()  //得到顺序表的长度

2.7  public void display() //打印顺序表

３完整代码

线性表

线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物

理上存储时，通常以数组和链式结构的形式存储。

eg.常见的线性表：顺序表、链表、栈、队列、字符串

顺序表

一段物理地址连续的存储单元依次存储数据元素的线性结构

创建MySequenceImpl类实现ISequence接口

顺序表接口：

package b.DS.link;
public interface ISequence {
        //在pos位置插入data
        boolean add(int pos,Object data);
        //查找关键词key 找到返回数组下标 没有返回-1
        int search(Object key);
        //判断是否包含关键词key是否在顺序表当中
        boolean contains(Object key);
        //得到pos的值
        Object getPos(int pos);t
        //删除第一次出现的关键字key
        Object remove(Object key);
        //得到顺序表的长度
        int size();
        //打印顺序表
        void display();
    }

１属性

a.数组：数组名为elem,数据类型为Object　　　

private Object[]　elem;

 b.有效数据长度：名称为Usedsize,数据类型为int类型

private int usedSize;

c.定义数组容量大小为10

public static final int=DEFAULT_SIZE=10;

 MySequenceImpl类的构造方法为属性初始化：

public MySequenceImpl() {//构造函数
        this.elem = new Object[DEFAULT_SIZE];//对数组elem初始化
        this.usedSize = 0;//数组长度的初始化
    }

２方法

 2.1public boolean add(int pos, Object data)//在pos位置插入data

核心思想：

１检查是否安全－－－不安全返回false

２检查数组是否为满-----为满返回false

３从usedSize-1位置向前遍历数组，pos位置时，前一个数赋值给后一个数，依次向后赋值，再将插入的数据data放入pos位置

代码：此处用到的数组扩容实质上是数组的浅拷贝（不会改变原数组对象）

  private boolean isFull() {
        return this.usedSize == this.elem.length;//有效长度等于数组长度------>满
    }
 @Override
    //在pos位置插入data
    public boolean add(int pos, Object data) {
        //1.pos位置的合法性进行
        if (pos < 0 || pos > this.usedSize) {//pos位置小于有效数组长度或者小于零-------不合法
            return false;
        }
        //2.判断是否为满
        if (isFull()) {
            //扩容两倍
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);//ArraysOf()参数：原始数组，新的长度
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];//把i的值给i+1    一直到把pos的值给pos+1
        }
        this.elem[pos] = data;
        this.usedSize++;//插入一个data后 有效数据长度+1
        return true;
    }

 2.2public int search(int key)//查找关键字key位置的数组下标

思想：

１判断数组是否为空－－－－返回－１

２遍历数组，用equals()方法，关键字key相同的值的地址，返回该数组下标（地址）

代码：

private boolean isEmpty() {//判断有效数组长度是否为0
        return this.usedSize == 0;
    }

    @Override
    //查找关键词key 找到返回数组下标 没有返回-1
    public int search(Object key) {
        if (isEmpty()) {
            return -1;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i].equals(key)) {//当数组elem里面的内容和关键字key  数值相等时
                return i;//满足上述条件时 返回数组elem的下标
            }
        }
        return -1;//没找到返回-1
    }

2. 3  public boolean contains(Object key)//判断是否包含关键词key是否在顺序表当中

思想：遍历数组，关键字key相同的值的地址，返回true,否则返回false


    @Override
    //判断是否包含关键词key是否在顺序表当中
    public boolean contains(Object key) {
        if (isEmpty()) {
            return false;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i].equals(key)) {//当数组elem里面的内容和关键字key  数值相等时
                return true;//满足上述条件时 返回true
            }
        }
        return false;//没包含key返回false
    }

2.4 public Object getPos(int pos)  //得到pos的值

１检查合法性

２返回this.elem[pos]就是pos位置当前的值

  @Override
    //得到pos的值
    public Object getPos(int pos) {
        if (pos < 0 || pos >= this.usedSize){//pos位置小于有效数组长度或者小于零-------不合法
            return null;
        }
        return this.elem[pos];//返回elem[pos]的值
    }

2.5  public Object remove(Object key)  //删除第一次出现的关键字key

思想：

１判断是否为空－－－－空的话就返回null

２调用search函数找到key的数组下标index

３定义Object类型变量Olddata来记录删除位置index的值

４遍历数组，使得后一个数赋值给前一个数，迭代，使得被删除的结点被覆盖掉

 @Override
    //删除第一次出现的关键字key
    public Object remove(Object key) {
        int index=search(key);//调用search()方法->找到key->将key赋值给index
        if(index==-1) {//如果没有关键词key----返回null
            return null;
        }
        Object data=this.elem[index];//保存index位置的值
        for(int i=index;i<usedSize-1;i++){//遍历顺序表->将某数的后一个数赋值给它本身
            this.elem[i]=this.elem[i+1];
        }
        this.usedSize--;
        return data;
    }

 2.6 public int size()  //得到顺序表的长度

思想：也就是数组有效长度

　 @Override
public int size() {
        return this.usedSize;//返回有效数组长度
    }

2.7  public void display() //打印顺序表

思想：遍历顺序表打印

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

３完整代码：


        import java.util.Arrays;
public class MySequenceImpl implements ISequence {
    private Object[] elem;//定义数组elem[] 数组名elem 数据类型为Object
    private int usedSize;//有效数据长度
    private static final int DEFAULT_SIZE = 10;//定义数组初始容量大小

    public MySequenceImpl() {//构造函数
        this.elem = new Object[DEFAULT_SIZE];//对数组elem初始化
        this.usedSize = 0;//数组长度的初始化
    }
    private boolean isFull() {
        return this.usedSize == this.elem.length;//有效长度等于数组长度------>满
    }
    @Override
    //在pos位置插入data
    public boolean add(int pos, Object data) {
        //1.pos位置的合法性进行
        if (pos < 0 || pos > this.usedSize) {//pos位置小于有效数组长度或者小于零-------不合法
            return false;
        }
        //2.判断是否为满
        if (isFull()) {
            //扩容两倍
            this.elem = Arrays.copyOf(this.elem, 2 * this.elem.length);//ArraysOf()参数：原始数组，新的长度
        }
        for (int i = this.usedSize - 1; i >= pos; i--) {
            this.elem[i + 1] = this.elem[i];//把i的值给i+1    一直到把pos的值给pos+1
        }
        this.elem[pos] = data;
        this.usedSize++;//插入一个data后 有效数据长度+1
        return true;
    }

    private boolean isEmpty() {//判断有效数组长度是否为0
        return this.usedSize == 0;
    }

    @Override
    //查找关键词key 找到返回数组下标 没有返回-1
    public int search(Object key) {
        if (isEmpty()) {
            return -1;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i].equals(key)) {//当数组elem里面的内容和关键字key  数值相等时
                return i;//满足上述条件时 返回数组elem的下标
            }
        }
        return -1;//没找到返回-1
    }

    @Override
    //判断是否包含关键词key是否在顺序表当中
    public boolean contains(Object key) {
        if (isEmpty()) {
            return false;
        }
        for (int i = 0; i < this.usedSize; i++) {
            if (this.elem[i].equals(key)) {//当数组elem里面的内容和关键字key  数值相等时
                return true;//满足上述条件时 返回true
            }
        }
        return false;//没包含key返回false
    }

    @Override
    //得到pos的值
    public Object getPos(int pos) {
        if (pos < 0 || pos >= this.usedSize){//pos位置小于有效数组长度或者小于零-------不合法
            return null;
        }
        return this.elem[pos];//返回elem[pos]的值
    }
    @Override
    //删除第一次出现的关键字key
    public Object remove(Object key) {
        int index=search(key);//调用search()方法->找到key->将key赋值给index
        if(index==-1) {//如果没有关键词key----返回null
            return null;
        }
        Object data=this.elem[index];//保存index位置的值
        for(int i=index;i<usedSize-1;i++){//遍历顺序表->将某数的后一个数赋值给它本身
            this.elem[i]=this.elem[i+1];
        }
        this.usedSize--;
        return data;
    }
    @Override
    //得到顺序表的长度
    public int size() {
        return this.usedSize;//返回有效数组长度
    }
    @Override
    //打印顺序表
    public void display() {
        for(int i=0;i<usedSize;i++){//遍历顺序表
            System.out.print(this.elem[i]+" ");
        }
        System.out.println("");
    }
}

调用：



public class Test1 {
    public static void main(String[] args) {
        MySequenceImpl mySequence=new MySequenceImpl();
        for(int i=0;i<20;i++){
            mySequence.add(i,i*2);//插入长度为20的数组 数组下标i  elem[i]=i*2
        }
        System.out.println("打印此顺序表：");
        mySequence.display();
        System.out.println( "此顺序表的长度:"+mySequence.size());//返回顺序表长度
        System.out.println("关键词10是否在顺序表当中:"+mySequence.contains(10));
        System.out.println( "查找关键词38(找到返回数组下标 没有返回-1):"+mySequence.search(38));
        Object res1=mySequence.getPos(1);
        System.out.println("pos为1时 elem[1]的值："+res1);
        Object res2=mySequence.remove(8);//删除关键字为8
        System.out.println("删除的值(key):"+res2);
        System.out.println("打印执行删除操作后的顺序表:");
        mySequence.display();
    }
}

运行结果：

运行结果

 

程序媛阿洁
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表+菜单
06-18
里面包括顺序表的创建，更改，添加，删除元素，遍历顺序表包括菜单功能，代码清晰，结构简单
线性表之顺序表
03-28
数据结构之顺序表，建表、查询、插入、删除，所有的过程
数据结构----顺序表Java实现
lgb1997的博客
06-03 418
顺序表定义： 顺序表是一种顺序存储的线性结构。比如A0 … Ai … An-1这样的表，表中的第一个元素是A0,表的最后一个元素是An-1,A0没有前驱元，An-1没有后继元，元素Ai在表中的位置是i+1,表中逻辑上相邻的两个元素在物理位置上也相邻。 下面是我写的一个小demo 定义接口 public interface IList { public int length();//获取顺序表的size public boolean isEmpty();//判断顺序表是否为空 publ
java 顺序查找法_Java经典算法汇总之顺序查找(Sequential Search)
weixin_30590615的博客
02-13 323
a)原理：顺序查找就是按顺序从头到尾依次往下查找，找到数据，则提前结束查找，找不到便一直查找下去，直到数据最后一位。b)图例说明： 原始数据：int[]a={4,6,2,8,1,9,0,3}; 要查找数字：8找到数组中存在数据8，返回位置。代码演示：import java.util.Scanner;/** 顺序查找*/public class SequelSearch {public static...
16 张图带你搞懂 Java 数据结构，从此想不飘都难！
最新发布
2401_84006989的博客
05-15 284
总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。本文已被。
数据结构之顺序表Java实现
qq_46620285的博客
12-29 800
线性表之顺序表 顺序表：把线性表中的所有元素按照顺序存储的方法进行存储，也就是用一组地址连续的存储单元依次存储线性表的数据元素。所以顺序表的逻辑顺序和物理顺序是一致的，但是物理位置比逻辑位置少1（因为逻辑顺序是从0开始的，而物理顺序是从1开始的，这一个细节是很重要的！！！） 顺序表的特点：1.顺序表的逻辑顺序和物理顺序是一致的，但是物理位置比逻辑位置少1（因为逻辑顺序是从0开始的，而物理顺序是从1开始的，这一个细节是很重要的！！！） 2.顺序表中任意一个数据元素可以随机存取，即顺序表是一种随机存取的数据结构
数据结构之顺序表的java实现
qq_40996164的博客
09-29 479
通过查找资料，再加上我的理解，初步建立了顺序表，可以实现的功能有：查值、取值、插入、删除。 1、建立一个接口，接口中存放你所希望的顺序表所实现的功能。 public interface List1 { //线性表接口List给出了任何实现线性表功能的类中必须要实现的成员函数原型 public int find(Object i) throws Exception;//查找 public Ob...
1_顺序表_
10-02
基于顺序存储结构的图书信息表的创建和输出描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据来完成图书信息表的创建，然后统计图书表中的图书个数，同时逐行输出每本图书的信息。...
2_顺序表_
10-01
基于顺序存储结构的图书信息表的修改描述定义一个包含图书信息（书号、书名、价格）的顺序表，读入相应的图书数据完成图书信息表的创建，然后计算所有图书的平均价格，将所有低于平均价格的图书价格提高20%，所有...
顺序表的实现
04-21
本代码为顺序表的基本操作，包括顺序表的初始化、长度、删除、插入、查找。
数据结构-顺序表 java实现
会飞的猪_的博客
03-15 285
知识点线性表的顺序结构存储结构简称为顺序表。线性表逻辑顺序相邻，顺序表存储位置相邻。便于随机存取。删除和插入可能要移动大量元素，效率低。解决溢出的方法是新建另一个大容量数组，效率低。实现List接口：public interface MyList { boolean isEmpty(); //判断是否为空 int listLength(); //返回表的长度 void a...
数据结构-顺序表(java)
qq_40395687的博客
09-04 246
package bh.shy.list; import org.junit.Test; import bh.shy.listconst.ListConst; public class MyList { // 定义一个数组T private T[] t; private int length; private int listSize; // 获取顺序表的长度 public int get...
数据结构之顺序表（java版）
梦之马
10-29 937
要点： 顺序表：采用顺序存储结构的线性表 顺序存储结构和链式存储结构不同，强调的是存储元素在物理地址存储的上连续！可实现随机存取（只要知道第一个元素的内存地址，再通过简单的加减就能找到任意一个元素了） 顺序表耗时在对移动元素上，进行插入、删除时都需要移动元素本人做顺序表的难点主要在于对顺序表进行插入时，需要多一个存储位，同时又要保存原来的数据 ，详情请看2的insert(int i, Ob
java数据结构之顺序表
林老师带你学编程
05-29 2186
1.顺序表中按位置随机访问的时间复杂度为O（1）； 2.顺序表中的在给定位置插入或者删除需要移动差不多一半的以上的元素，所以时间复杂度为O（n）； 3.存储密度=数据占用的存储量/整个结点占用的存储量。根据这个公式可以得出顺序表的存储密度为1； 所以可以得出以下结论：线性表一般作为查询频繁，插入或者删除比较少的场景下使用。空间使用率上面是比较高的。 下面直接上代码举例说明： publ
数据结构之顺序表（Java实现）
Easenyang的博客
05-10 826
顺序表概述二级目录二级目录二级目录二级目录 顺序表概述 简介： 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 顺序表存储示意图： 二级目录 二级目录 二级目录 二级目录 ...
数据结构_顺序表的java实现
叶清逸的博客
07-27 605
这篇文章讲述的是数据结构部分的顺序表的java实现，如有错误或者不当之处，还望各位大神批评指正。 顺序表的特点 因为物理结构和逻辑结构均连续 删除和添加会比较麻烦 顺序储存要求明确数据的规模用来分配数据空间 数据的存取比较简易 顺序表的基本操作 init:初始化顺序表 destroy：销毁数据表 clear：清空数据表中的元素 length：获取数据表长度 get：获取索引位置的元素...
数据结构java实现_数据结构的Java实现——顺序表
weixin_28786857的博客
02-20 59
顺序表： 线性表的顺序表是，指的是用一组地址连续的存储单元一次存储线性表的数据元素。以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。只要确定了存储线性表的起始位置，线性表中任何一数据元素都可以随机存取，所以线性表的存储结构是一种随机存取的存储结构。由于高级程序设计语言中的数组类型也具有随机存取的特性，因此，通常都用数组来描述数据结构中的顺序存储结构。优点——随机存储，读取数据...
数据结构：今日主角就是你初章——顺序表JAVA
weixin_43914278的博客
05-26 170
我是小咲，数据结构是一门负责而又神秘的学科，为什么这么说呢，因为不告诉你？ 神秘不神秘啊？ 主要原因是讨论的主题不是数据结构啦，而是 顺序表 说到顺序表，顾名思义不是链表，而是一个个紧挨着的相邻房间的存储方式，下面就来看看代码的实际编写啦 写的代码功能不多 就是头插尾插一类的而已 特别的：ensureCapacity（确保空间大小） package sequenceli...
顺序表 displist
03-09
顺序表（displist）是一种线性表的存储结构，它通过一段连续的存储空间来存储元素，元素之间的逻辑关系由下标来表示。顺序表的特点是可以随机访问元素，时间复杂度为O(1)。 顺序表的实现方式有多种，其中一种常见的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值