java实现简单数据结构--线性表

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

线性表简介

什么是线性表

在《数据结构简明教程》中如此定义，线性表是由n(n>=0)个相同类型数据元素组成的有限序列。

线性表是一个逻辑结构的概念，

线性表的性质

  • a[i-1]是a[i]的前驱元素，a[i+1]是a[i]的后继元素
  • 若至少含有一个元素，则只有唯一的开始元素和终端元素，除了开始元素外其他元素有且只有一个前驱元素；除了终端节点外其他元素有且仅有一个后继元素
  • 线性表中每个元素有唯一的序号，同一个线性表中可以存在值相同的多个元素，但他们的序号不相同

存储结构

  • 顺序表
  • 链表

线性表接口

MyList

该接口为整个线性表的抽象，声明了几种常用的方法

使用object类：因为java中所有类都继承object类，所以使用object类可以更加抽象的定义出接口，让其更加适用于所有类型

package com.brozha.datastruct.linearlist;

/**
 * @author brozha
 * @since 2021/4/12
 */
public interface MyList {

    //返回顺序表的长度
    public int size();
    //判断是否为空
    public boolean isEmpty();
    //判断是否包含元素e，如果找到就返回下标（从0开始），如果没找到就返回-1
    public int indexOf(Object e);
    //将数据元素e插入到第i号(i从0开始)，将原位置的i后移，成功返回为true，失败返回为false
    public boolean insert(Object e,int i);
    //删除第i个位置上的元素
    public boolean remove(int i);
    //获取第i个元素，获取失败则抛出异常
    public Object get(int i) throws IndexOutOfBoundsException;
    //替换i位置上的值为e，返回失败说明数组越界
    public boolean replace(int i,Object e);


}

顺序表

定义

顺序表是线性表采用顺序存储结构在计算机内存中的存储方式，它由多个连续的存储单元构成，每个存储单元存放线性表的一个元素，逻辑上相邻的数据元素在内存中也是相邻的，不需要额外的内存空间来存放元素之间的逻辑关系。顺序表是线性表的直接映射。

也就是说我们可以得出以下公式：

LOC(a[i+1])=LOC(a[i])+K ===> LOC(a[i])=LOC(a[0])+i*K（其中K为每个元素需要占用K个存储单元，LOC代表该元素的存储地址）

MyArrayList实现

package com.brozha.datastruct.linearlist;

import java.util.ArrayList;
import java.util.Arrays;

/**
 * @author brozha
 * @since 2021/4/12
 */
public class MyArrayList implements MyList{

    private static final int DEFAULT_LEN = 8;  //数组默认的大小
    private int size;       //元素个数
    private Object[] elements;      //存放元素的数组


    public MyArrayList(){
        this(DEFAULT_LEN);
    }


    public MyArrayList(int len){
        size = 0;
        elements = new Object[len];
    }



    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size>0;
    }

    /**
     *
     * @param e
     * @return  返回第一次出现的下标，-1表示没找到
     */
    @Override
    public int indexOf(Object e) {
        for(int i = 0;i<size;i++){
            if(e.equals(elements[i])){
                return i;
            }
        }
        return -1;
    }

    /**
     * 在下标为i的元素之前插入e
     * @param e
     * @param i     如果i刚好==size，则插入的位置为最后
     * @return  如果插入成功则返回true，下标越界则返回false，越界的意思是在size之后
     *
     */
    @Override
    public boolean insert(Object e, int i) {
        if(i<0||i>size){
            return false;
        }
        //如果已经满了，则先进行扩容
        if(size>=elements.length){
            expandSpace();
        }
        //将i元素以及其之后的元素向后移，再在i处插入e
        for(int j=size;j>i;j--){
            elements[j] = elements[j-1];
        }
        elements[i] = e;
        size++;
        return true;
    }

    @Override
    public boolean remove(int i) {
        if(i<0||i>=size){
            return false;
        }
        for(int j = i;j<size-1;j++){
            elements[j] = elements[j+1];
        }
        size--;
        return true;
    }

    @Override
    public Object get(int i) throws IndexOutOfBoundsException {
        if(i<0||i>=size){
            throw new IndexOutOfBoundsException("下标"+i+"越界了");
        }
        return elements[i];
    }

    @Override
    public boolean replace(int i, Object e) {
        if(i<0||i>=size){
            return false;
        }
        elements[i] = e;
        return true;
    }

    //扩容
    private void expandSpace(){
        //扩容1.5倍
        int newLength = elements.length+(elements.length>>1);
        //也可以用循环手动扩容
        elements = Arrays.copyOf(elements,newLength);
        System.out.println("扩容后的总容量"+elements.length);
    }
}

思考：深拷贝和浅拷贝？Arrays.copyOf是深拷贝还是浅拷贝？

简单测试（简单的测试了一下，测试可能不完全），若有bug请读者告知

package com.brozha.datastruct.linearlist;

/**
 * @author brozha
 * @since 2021/4/12
 */
public class ArrayListTest {
    public static void main(String[] args) {
        MyArrayList mal = new MyArrayList();
        System.out.println("初始的长度为："+mal.size());
        for(int i=0;i<15;i++){
            mal.insert(i,i);
        }
        System.out.println("插入15个数之后的值：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        mal.remove(5);
        System.out.println("删除下标为5的数后：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        mal.insert(88,5);
        System.out.println("在下标为5的数前插入88：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        System.out.println("数字10第一次出现的下标为："+mal.indexOf(10));
        System.out.println("数字12312第一次出现的下表为："+mal.indexOf(12312));

        mal.replace(10,12312);
        System.out.println("将下标为10的数替换为12312：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        System.out.println("数字12312第一次出现的下表为："+mal.indexOf(12312));
    }
}

测试结果

image-20210412233404567

链表

定义

线性表的链式存储结构中每个元素的存储空间作为一个节点单独分配，因此逻辑上相邻的元素对应的节点物理上不一定是相邻的，通过增加指针域表示逻辑关系，在插入和删除操作时只需要修改相应的指针域，从而克服了顺序表中插入和删除操作需要移动大量元素的弱点，但同时也失去了顺序表可随机存取的优点。

Node类（单链表）

package com.brozha.datastruct.linearlist;

/**
 * @author brozha
 * @since 2021/4/14
 */
public class Node {
    public Object val;
    public Node next;
    public Node(){};
    public Node(Object val){
        this.val = val;
    }
}

单链表实现的线性表

package com.brozha.datastruct.linearlist;

/**
 * @author brozha
 * @since 2021/4/14
 */
public class MyLinkedList implements MyList{


    int size;
    Node node;
    MyLinkedList(){
        size = 0;
        //相当于是有一个头结点的
        node = new Node();
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size>0;
    }

    @Override
    public int indexOf(Object e) {
        Node p = node.next;
        int i = 0;
        while(p!=null){
            if(p.val.equals(e)){
                return i;
            }
            i++;
            p = p.next;
        }
        return -1;
    }

    //将e插入到第i个位置，后面的往后移动
    @Override
    public boolean insert(Object e, int i) {
        if(i<0||i>size){
            return false;
        }
        Node p = node;
        int k = 0;
        while(k<i){
            k++;
            p = p.next;
        }
        Node q = new Node();
        q = p.next;
        p.next = new Node(e);
        p.next.next = q;
        size++;
        return true;
    }

    @Override
    public boolean remove(int i) {
        if(i<0||i>=size){
            return false;
        }
        Node p = node;
        int k = 0;
        while(k<i){
            k++;
            p = p.next;
        }
        p.next = p.next.next;
        size--;
        return true;
    }

    @Override
    public Object get(int i) throws IndexOutOfBoundsException {
        if(i<0||i>=size){
            throw new IndexOutOfBoundsException(i+"越界了！！！");
        }
        Node p = node.next;
        int k = 0;
        while(k<i){
            k++;
            p = p.next;
        }
        return p.val;
    }

    @Override
    public boolean replace(int i, Object e) {
        if(i<0||i>=size){
            return false;
        }
        Node p = node.next;
        int k = 0;
        while(k<i){
            k++;
            p = p.next;
        }
        p.val = e;
        return true;
    }

    @Override
    public void add(Object e) {
        //头插法
        Node p = new Node(e);
        p.next = node.next;
        node.next = p;
        size++;
    }
}

测试类

package com.brozha.datastruct.linearlist;

/**
 * @author brozha
 * @since 2021/4/12
 */
public class ListTest {
    public static void main(String[] args) {
        MyList mal = new MyLinkedList();
        System.out.println("初始的长度为："+mal.size());
        for(int i=0;i<15;i++){
            mal.insert(i,i);
        }
        System.out.println("插入15个数之后的值：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        mal.remove(5);
        System.out.println("删除下标为5的数后：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        mal.insert(88,5);
        System.out.println("在下标为5的数前插入88：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        System.out.println("数字10第一次出现的下标为："+mal.indexOf(10));
        System.out.println("数字12312第一次出现的下表为："+mal.indexOf(12312));

        mal.replace(10,12312);
        System.out.println("将下标为10的数替换为12312：");
        for(int i=0;i<mal.size();i++){
            System.out.print(mal.get(i)+" ");
        }
        System.out.println();
        System.out.println("数字12312第一次出现的下表为："+mal.indexOf(12312));
    }
}

image-20210414004437443

可爱扎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【java数据结构】线性表(顺序表及链表)及其实现
DempseyLee的博客
03-12 1742
01 引入： 多项式的表示 方法一：顺序结构直接表示（数组） 方法二：顺序存储结构存储非零项 方法三： 链表结构存储非零项 02 什么是线性表 线性表”：由同类型数据元素构成有序序列的线性结构 表中元素个数称为线性表的长度 线性表没有元素时，称为空表 表起始位置称为表头，表结束位置称表尾 说明：线性表也就是数组的一种特殊储存方式：从头到尾依次储存数据。 2.1 线性表抽象数据类型概述 线性表操作接口描述 public...
java数据结构，线性表顺序存储（数组）的实现
m0_63622279的博客
11-20 1209
线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。接着用类去实现这一接口，重写其中的全部方法，因为有一些操作，使用静态方法更便捷，所以接口中只是部分的基础操作，线性表的增删改查。7）Insert（L，i，x）在表L的位置i处插入元素x，将原占据位置i的元素及后面的元素都向后推一个位置。数据结构陆续更新中！3）Get（L，i） 这是一个函数，函数值为L中位置i处的元素（1≤i≤n）6）Locate（L，x） 这是一个函数，函数值为元素x在L中的位置。
数据结构之线性表(Java版)
qq_52374254的博客
10-02 2200
一、线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种"一对一"的逻辑关系 第一个 数据元素没有前驱，这个数据元素被称为头结点 最后一个数据元素没有后继，这个数据元素被称为尾结点 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继 如.
数据结构（1）线性结构——数组、链表、堆栈、队列（介绍和JAVA代码实现）
Joker_ZJN的博客
11-10 1268
详细介绍、数组、链表、堆栈、队列，包含JAVA版代码实现
线性表的顺序存储及实现
qq_34228115的博客
10-06 335
线性表的顺序存储 public interface IList { public void clear(); // 将一个已经存在的线性表置成空表 public boolean isEmpty(); // 判断当前线性表中的数据元素个数是否为0,若为0则函数返回true，否则返回false public int length(); // 求线性表中的数据元素个数并由函数返回其值 public ...
数据结构与算法分析--线性表实现
04-01
线性表是计算机科学中一种...总结起来，线性表的实现涉及数据结构的选择、插入和删除操作的实现以及效率优化。通过理解这些概念，开发者可以更好地设计和实现适应不同场景的线性表数据结构，提高程序的性能和可维护性。
数据结构-线性表-Java代码实现
03-20
关于线性表的Java实现代码 有顺序表，带头结点的单链表的实现代码，顺序表里包含插入，删除，求数据元素个数，取数据元素，判断非空否，以及顺序表中删除第一个出现的数据元素x,以及把顺序表中所有等于x的数据元素...
数据结构线性表-顺序表（c++、java）.pdf
最新发布
11-12
理解并熟练运用这些操作对于理解和实现其他复杂数据结构，如链表、树、图等，都至关重要。在实际编程中，应考虑优化这些操作的效率，例如通过数组扩容策略减少频繁的内存分配，或者使用其他数据结构（如链表）来提高...
数据结构(Java版)-线性表的实现与应用完整版.doc
10-01
"数据结构(Java版)-线性表的实现与应用完整版" 本文旨在通过Java实现线性表的基本操作，并应用于实际问题中。线性表是一种基本的数据结构，广泛应用于计算机科学和软件开发中。本文将通过两个部分来介绍线性表的...
数据结构工程----线性表的实现
07-30
1．顺序存储 顺序表，使用数组实现，一组地址连续的存储单元，数组大小有两种方式指定，一是静态分配，二是动态扩展。 注：线性表从1开始，而数组从0开始。...Java中使用嵌套类来定义节点的抽象数据类型：
Java数据结构——线性表
m0_51274044的博客
11-28 1360
线性表的顺序表示和实现 线性表的顺序表示形式： 用一组地址连续的存储单元依次存储线性表中的数据元素 在接口中定义方法： package qianyu.ch02; public interface MyArrayList { //定义一些方法 //查询线性表中数据元素个数 int getSize(); //判断线性表是否为空 boolean isEmpty(); //在线性表指定索引位置处插入元素 void insert(int i,Object e); //判断线性表中是否存在元素.
【Java数据结构】线性表
m0_51692337的博客
01-03 427
线性表我认为就是数组。。。 创建： private int[] elements;//元素 private int size;//List中当前的元素个数 public MyArrayList() { this(1);//List默认大小为1 } /** * 按指定大小capacity构造List * * @param capacity List初始化时的大小 */ public MyArrayList(in
Java实现线性表之顺序表
qq_42200733的博客
12-31 823
顺序表的Java实现 线性表 线性表是一种相当简单灵活的数据结构，是我们学习数据结构的基础。线性表中的元素存在一对一的关系。例如，将学生按学号进行先后顺序的排列。 线性表可以用顺序存储和链式存储，顺序存储适合进行多次访问，而链式存储适合多次插入和删除。 顺序表 顺序储存结构就是借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系，通常借助程序设计语言的数组类型来描述。 数据元素 新建一个类来封...
java中线性结构的例子_java数据结构--线性结构
weixin_29615645的博客
02-27 783
一、数据结构数据结构由数据和结构两部分组成，就是将数据按照一定的结构组合起来，这样不同的组合方式有不同的效率，可根据需求选择不同的结构应用在相应在场景。数据结构大致分为两类：线性结构(如数组，链表，队列，栈等)，非线性结构(如树，图，表等)。本文介绍下线性结构，下章介绍非线性结构。二、数组数组表示一组有限个相同类型的数据的集合，顺序存储，下标从0开始，其特点是可以根据下标快速的查找到元素，但在增加...
java基础--数据结构线性
qq_28409161的博客
07-22 98
java基础--数据结构线性。
数据结构与算法 —— Java 实现（线性表）
欢迎来到Gorit的博客
03-20 2358
数据结构与算法 （Java 语言实现） —— 线性表一、Java 数组的回顾学习二、使用 OOP 编写变长数组2.0 准备2.1 实现 add 动态添加一个元素2.2 实现 delete 删除任意一个位置的元素2.3 实现 size 方法获取当前数组的长度2.4 实现 get 获取指定下标的元素2.5 实现 insert 在任意位置插入一个元素2.6 实现 set 替换任意一个元素 一、Java ...
java线性表_Java数据结构之线性表
weixin_35816805的博客
02-12 189
线性表是其组成元素间具有线性关系的一种数据结构，对线性表的基本操作主要有，获取元素，设置元素值，遍历，插入，删除，查找，替换，排序等。而线性表可以采用顺序储存结构和链式储存结构，本节主要讲解顺序表、单链表以及双链表的各种基本操作。1：线性表抽象的数据类型线性表：是由n(n>=0)个数据相同的元素组成的有限序列。线性表的定义接口如下public interface IList {/*** 是否...
数据结构学习2--线性表的设计与实现（一）
请叫我搞向
09-13 1325
导语：本博客将带大家入门线性表，重点讲解一个顺序存储的财富库，代码比较详细。 1 线性表的基本概念 线性表(List)是零个或多个数据元素的集合 线性表中的数据元素之间是有顺序的 线性表中的数据元素个数是有限的 线性表中的数据元素的类型必须相同 最通俗的解释：我们最常见的数组、链表就是线性表。
Java数据结构与算法—及实现 线性表 顺序表、链表、栈、队列详解
caobing123321的博客
03-13 629
数据结构与算法是程序设计的两大基础，大型的IT企业面试时也会出数据结构和算法的题目，它可以说明你是否有良好的逻辑思维，如果你具备良好的逻辑思维，即使技术存在某些缺陷，面试公司也会认为你很有培养价值，至少在一段时间之后，技术可以很快得到提高。同时，它也是软考的重点，我们需要对这部分的内容进行一下总结。我们先看一下数据结构和算法的整体内容。1、线性表概念：数据元素的排列方式是线性的。分类：分类规则是根...
Java版数据结构-线性表实现与应用解析
"该资源是一份关于数据结构的Java版线性表实现与应用的完整实验报告，旨在帮助学生理解并掌握线性表在顺序表和单链表两种形式下的实现，以及如何利用它们解决实际问题。实验内容包括实现线性表接口中定义的基本操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值