Java 数据结构线性表之顺序存储详解原理

2024-04-02 19:04:59 790人浏览泡泡鱼

Python 官方文档：入门教程 => 点击学习

摘要

目录线性表的定义线性表的基本运算线性表的存储之顺序存储定义线性表添加元素查找元素删除元素打印线性表实现的完整代码测试一下线性表的定义线性表的逻辑特征： ①有且仅有一个称为

线性表的定义

线性表的逻辑特征：

①有且仅有一个称为开始元素的a1，她没有前趋，仅有一个后继结点a2；
②有且仅有一个称为终端元素的an,他没有后继，只有一个直接前驱a(n-1)；
③其余元素ai(2≤i≤n-1)称为内部元素，他们都有且仅有一个直接前驱a(i-1)和直接后继a(i+1)。

在这里插入图片描述

线性表的图像表示

线性表的基本运算

线性表初始化
求表长
按索引值查找元素
按值查找
插入元素
删除

线性表的存储之顺序存储

线性表顺序存储的定义：线性表的顺序存储指的是将线性表的数据元素按其逻辑次序依次存入一组连续的存储单元里，用这种方式存储的线性表称为顺序表。

定义线性表

定义线性表的默认空间大小，定义一个数组，定义数组的长度，初始化一个size用来保存里面元素的个数。


 	
    private final Integer ListSize=100;
    
    private Integer Len;
    
    private Object[] list;
    
    private Integer size=0;
    
    public SeqList(){
        Len = ListSize;
        this.list = new Object[Len];
        size++;
    }

初始化线性表

把线性表里面的元素全部置空


	
    public void clear(){
        for (int i = 0; i < size; i++) {
            list[i]=null;
        }
        size=0;
    }

添加元素

这里采用尾插法，即每次默认将元素放在最后面


	
    public void insert(T element , int index){
        if(index>=Len || index<0){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
        }
        Capacity(size+1);
        //将添加元素的元素往后移一位
        for (int i = size-2; i >= index-1; i--) {
            list[i+1]=list[i];
        }
        list[index-1]=element;
        size++;
    }
    
    public void add(T element){
        insert(element,size);
    }

查找元素

这个模块分为按索引值查找，和按元素值查找


	
    public T getnode(int index){
        return (T)list[index-1];
    }
    
    public int LocateNode(T t){
        for(int i=0;i<list.length;i++){
            if(list[i].equals(t)){
                return i+1;
            }
        }
        System.out.println("没有找到该元素！");
        return -1;
    }

删除元素

删除元素，又分为删除指定元素，和删除最后一个元素


    
    public T delete(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("删除位置不在线性表的索引范围内！");
        }
        for (int i = index-1; i < size-1; i++) {
            list[i]=list[i+1];
        }
        
        list[size-1]=null;
        size--;
        return (T) list;
    }
    
    public T remove(){
        return delete(size-1);
    }

打印线性表

打印线性表，其实就是重写一个toString方法，将线性表打印出来



    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        if(isEmpty()){
            return "[]";
        }
        else {
            sb.append("[");
            for (int i = 0; i < size-1; i++) {
                int a=0;
                if(list[i]!=null){
                    sb.append(list[ i ]);
                }
                else {
                    break;
                }
                sb.append(",");
            }
            sb.append("]");
            sb.deleteCharAt(sb.indexOf(",]"));
        }
        return sb.toString();
    }

实现的完整代码


class SeqList<T>{
    
    private final Integer ListSize=100;
    
    private Integer Len;
    
    private Object[] list;
    
    private Integer size=0;
    
    public SeqList(){
        Len = ListSize;
        this.list = new Object[Len];
        size++;
    }
    
    public SeqList(int length){
        Len = length;
        list = new Object[Len];
        size++;
    }
    
    public int getLen(){
        return Len;
    }
    
    public int getSize(){
        return size;
    }
    
    public int getIndex(T element){
        for (int i = 0; i < size; i++) {
            if(list[i].equals(element)){
                return i;
            }
        }
        return -1;
    }
    
    private boolean OutIndex(int index){
        //return size==Len;//不扩容的话，可以这样写，但是怕扩容
        if(index>size || index<0){
            return false;
        }
        else {
            return true;
        }
    }
    
    private T getElement(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
            
        }
        return (T)list[index];
    }
    
    private T Capacity(int capacity){
        if(capacity<Len){
            Len = Len+(Len+1)/2;
            if(capacity<Len){
                Capacity(Len);
            }
            else {
                list = Arrays.copyOf(list,Len);
                return (T) list;
            }
        }
        return (T)list;
    }
    
    public void insert(T element , int index){
        if(index>=Len || index<0){
            throw new IndexOutOfBoundsException("输入的索引值超过了线性表的范围");
        }
        Capacity(size+1);
        //将添加元素的元素往后移一位
        for (int i = size-2; i >= index-1; i--) {
            list[i+1]=list[i];
//            System.out.println("i="+i);
        }
        list[index-1]=element;
        size++;
    }
    
    public void add(T element){
        insert(element,size);
    }
    
    public boolean isEmpty(){
        return size==0;
    }
    
    public T delete(int index){
        if(!OutIndex(index)){
            throw new IndexOutOfBoundsException("删除位置不在线性表的索引范围内！");
        }
        for (int i = index-1; i < size-1; i++) {
            list[i]=list[i+1];
        }
        
        list[size-1]=null;
        size--;
        return (T) list;
    }
    
    public T remove(){
        return delete(size-1);
    }
    
    public void clear(){
        for (int i = 0; i < size; i++) {
            list[i]=null;
        }
        size=0;
    }
    
    public T getNode(int index){
        return (T)list[index-1];
    }
    
    public int LocateNode(T t){
        for(int i=0;i<list.length;i++){
            if(list[i].equals(t)){
                return i+1;
            }
        }
        System.out.println("没有找到该元素！");
        return -1;
    }
    
    @Override
    public String toString(){
        StringBuilder sb = new StringBuilder();
        if(isEmpty()){
            return "[]";
        }
        else {
            sb.append("[");
            for (int i = 0; i < size-1; i++) {
                int a=0;
                if(list[i]!=null){
                    sb.append(list[ i ]);
                }
                else {
                    break;
                }
                sb.append(",");
            }
            sb.append("]");
            sb.deleteCharAt(sb.indexOf(",]"));
        }
        return sb.toString();
    }
}

测试一下

测试代码


	public static void main(String[] args) {
        SeqList<String> seqList = new SeqList<String>();
        //添加一个元素
        seqList.add("pier");
        seqList.add("真好看");
        seqList.add("90度点头");
        System.out.println("添加后的线性表为\n\t"+seqList.toString());
        seqList.insert("pipi",1);
        System.out.println("在位置1的地方添加元素后的线性表为\n\t"+seqList.toString());
        seqList.delete(1);
        System.out.println("删除第二个元素后的线性表为\n\t"+seqList.toString());
        System.out.println("pier时第"+seqList.LocateNode("pier")+"个元素");
        System.out.println("第1个元素是"+seqList.getNode(1)+"。");
    }

运行结果

到此这篇关于Java 数据结构线性表之顺序存储详解原理的文章就介绍到这了,更多相关Java 数据结构内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！

您可能感兴趣的文档:

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: Java 数据结构线性表之顺序存储详解原理

本文链接: https://www.lsjlt.com/news/155365.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

Java 数据结构线性表之顺序存储详解原理

目录线性表的定义线性表的基本运算线性表的存储之顺序存储定义线性表添加元素查找元素删除元素打印线性表实现的完整代码测试一下线性表的定义线性表的逻辑特征： ①有且仅有一个称为...

99+

2022-11-12
Java数据结构顺序表用法详解

目录1.什么是顺序表2.顺序表的基本功能和结构3.顺序表基本功能的实现和解析1.判断线性表是否为空2.获取指定位置的元素3.向线性表表添加元素4.在位置i处插入元素5.删除指定位置的...

99+

2022-11-12
Java数据结构之顺序表和链表精解

目录前言1. 顺序表代码实现2. 链表链表图解代码实现前言两个数据结构：顺序表和链表数据结构是一门学科，和语言无关。数据 + 结构：一种描述和组织数据的方式。 1. 顺序表顺...

99+

2022-11-12
C语言编程数据结构线性表之顺序表和链表原理分析

目录线性表的定义和特点线性结构的特点线性表顺序存储顺序表的元素类型定义顺序表的增删查改初始化顺序表扩容顺序表尾插法增加元素头插法任意位置删除任意位置添加线性表的链式存储数据域与指针域...

99+

2022-11-12
Java数据结构顺序表的详细讲解

目录写在前面1.线性表2.顺序表的实现2.1增加数据2.1.1尾部增加数据2.1.2任意位置增加数据2.2查找数据2.3删除数据2.4修改数据3.ArrayList3.1ArrayL...

99+

2022-11-13
Java数据结构之栈的线性结构详解

目录一：栈二：栈的实现三：栈的测试四：栈的应用（回文序列的判断）总结一：栈栈是限制插入和删除只能在一个位置上进行的表，此位置就是表的末端，叫作栈顶。栈的基本操作分为push(入...

99+

2022-11-12
C语言数据结构之线性表的链式存储结构

1.什么是线性表的链式存储结构 —链表存储结点：包括元素本身的信息，还有元素之间的关系逻辑的信息这个结点有：数据域和指针域一个指针域：指向后继结点，单链表二个指针域：指向...

99+

2022-11-12
Java 数据结构深入理解ArrayList与顺序表

目录一、ArrayList简介二、ArrayList的使用1、ArrayList的构造2、ArrayList的遍历3、ArrayList的常见操作(方法)4、ArrayList的扩容...

99+

2022-11-13
C语言数据结构之单链表存储详解

目录1、定义一个链表结点2、初始化单链表3、输出链表数据4、完整代码如果说，顺序表的所占用的内存空间是连续的，那么链表则是随机分配的不连续的，那么为了使随机分散的内存空间串联在一起形...

99+

2022-11-13
如何理解C语言数据结构中线性表的链式存储结构

如何理解C语言数据结构中线性表的链式存储结构，相信很多没有经验的人对此束手无策，为此本文总结了问题出现的原因和解决方法，通过这篇文章希望你能解决这个问题。1.什么是线性表的链式存储结构 —链表存储结点：包括元素本身的信息，还有元素之间的关系...

99+

2023-06-21
C语言数据结构之数组模拟实现顺序表流程详解

目录线性表和顺序表线性表顺序表静态顺序表动态顺序表代码已经放在Gitee上，需要可以小伙伴可以去看看用C语言数组模拟实现顺序表 Gitee 线性表和顺序表线性表线性表（line...

99+

2022-11-12
C语言数据结构不挂科指南之线性表详解

目录基本概念线性表的顺序存储线性表的顺序存储的时间复杂度线性表的链接存储线性表在单链表上实现基本运算初始化初始化成功，开始插入元素单链表的时间复杂度循环链表双向循环链表期末考试基本概...

99+

2022-11-13
Java数据结构之最小堆和最大堆的原理及实现详解

目录一、前言二、堆的数据结构三、堆的代码实现1. 实现介绍2. 入堆实现3. 出堆实现4. 小堆实现5. 大堆实现一、前言堆的历史堆的数据结构有很多种体现形式，包括；2-3堆、B...

99+

2022-11-13