【Java数据结构】初识线性表之一：顺序表

最新推荐文章于 2024-09-10 10:21:38 发布
最新推荐文章于 2024-09-10 10:21:38 发布
阅读量1.6k 收藏 75
点赞数 87
分类专栏： 数据结构 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yican2580/article/details/140336468
版权

使用Java简单实现一个顺序表

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

线性表大致包含如下的一些方法：

public class MyArrayList {
    private int[] array;
    private int size;
    // 默认构造方法默认分配空间
    SeqList(){   }
    // 将顺序表的底层容量设置指定容量
    SeqList(int initcapacity){   }

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

 接下来根据上面的方法实现一个 int 类型的顺序表：

import java.util.Arrays;
public class MyArrayList {
    private int[] elem;
    private int usedSize;
    private static final int DEFAULT_SIZE = 10;
    public MyArrayList(){
        elem = new int[DEFAULT_SIZE];
    }
    public MyArrayList(int initCapacity){
        elem = new int[initCapacity];
    }

    private boolean checkCapacity(){
        if(this.usedSize == elem.length){
            return true;
        }
        return false;
    }

    public void display(){
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.elem[i] + " ");
        }
    }
    public void add(int data){
        if(checkCapacity()){
            this.elem = Arrays.copyOf(this.elem,2*elem.length);
        }
        this.elem[this.usedSize] = data;
        this.usedSize++;
        return;
    }
    public void add(int pos,int data){
        if(pos > this.usedSize || pos < 0){
            throw new PosOutOfBoundsException("插入位置错误！");
        }
        if(checkCapacity()){
            this.elem = Arrays.copyOf(this.elem,2*elem.length);
        }
        for (int i = this.usedSize - 1; i >=pos ; i--) {
            elem[i+1] = elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
        return;
    }

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

    public int indexof(int data){
        for (int i = 0; i < this.usedSize; i++) {
            if(this.elem[i] == data){
                return i;
            }
        }
        return -1;
    }
    public int get(int pos){
        if(pos >= this.usedSize || pos < 0){
            throw new PosOutOfBoundsException("输入的位置错误！");
        }
        return this.elem[pos];
    }
    public void set(int pos,int data){
        if(pos >= this.usedSize || pos < 0){
            throw new PosOutOfBoundsException("输入的位置错误！");
        }
        this.elem[pos] = data;
    }
    public int size(){
        return this.usedSize;
    }
    public void remove(int data){
        if(this.contains(data)){
            int pos = this.indexof(data);
            for (int i = pos; i < this.usedSize - 1; i++) {
                this.elem[pos] = this.elem[pos+1];
            }
            this.usedSize--;
        }else{
            throw new PosOutOfBoundsException("没有该元素");
        }
    }
    public void clear(){
        this.usedSize = 0;
        return;
    }
}

ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：

  • ArrayList是以泛型方式实现的，使用时必须要先实例化
  • ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  • ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  • ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  • 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者
  • CopyOnWriteArrayList
  • ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

ArrayList如何使用

ArrayList的构造方法

ArrayList中的构造方法：

ArrayList()；//无参构造

ArrayList(Collection<? extends E> c)；//利用其他 Collection 构建 ArrayList

ArrayList(int initialCapacity)；//指定顺序表初始容量

 代码示例：

public class Test {
    public static void main(String[] args) {
        List<Integer> list1 = new ArrayList<>();//无参构造
        List<Integer> list2 = new ArrayList<>(10);//指定容量
        list2.add(1);
        list2.add(2);
        list2.add(3);
        List<Integer> list3 = new ArrayList<>(list2);//利用其他 Collection 构建 ArrayList
    }
}

ArrayList常见操作

尾插

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();//无参构造
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
    }
}

将元素插入到指定位置

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1,4);
        System.out.println(list);
    }
}

尾插另一个顺序表中的元素

public class Test {
    public static void main(String[] args) {
        List<Integer>  list1 = new ArrayList<>();
        list1.add(4);
        list1.add(5);
        list1.add(6);
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.addAll(list1);
        System.out.println(list);
    }
}

删除指定位置元素

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.remove(1);
        System.out.println(list);
    }
}

删除指定数据

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.remove(new Integer(2));
        System.out.println(list);
    }
}

获取指定位置元素

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.get(1));
    }
}

将指定位置元素设置为新数据

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.set(1,4);
        System.out.println(list);
    }
}

清空顺序表

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.clear();
        System.out.println(list);
    }
}

判断一个元素是否在顺序表中

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.contains(2));
        System.out.println(list.contains(4));
    }
}

返回第一个指定元素所在下标

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        System.out.println(list.indexOf(1));
    }
}

返回最后一个指定元素所在下标

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        System.out.println(list.lastIndexOf(1));
    }
}

截取部分list

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.subList(0,2));
    }
}

遍历 ArrayList 的三种方法

ArrayList 可以使用三方方式遍历：for循环+下标、foreach增强循环、使用迭代器

public class Test {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //使用fori遍历
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));
        }
        System.out.println();
        //使用foreach遍历
        for(Integer integer:list){
            System.out.print(integer);
        }
        System.out.println();
        //使用迭代器遍历
        Iterator<Integer> it = list.listIterator();
        while(it.hasNext()){
            System.out.print(it.next());
        }
    }
}

运行结果：

 ArrayList的场景使用

洗牌算法

将一副扑克牌随机打乱，并分配给三个人，每人五张牌

算法原码所在位置：

shufflecards · 一直淡水鱼/Java经典例题 - 码云 - 开源中国 (gitee.com)

杨辉三角

题目描述：

代码实现：

public class Test {
    public static List<List<Integer>> generate(int numRows) {
        List<List<Integer>> list = new LinkedList<>();
        for (int i = 0; i < numRows; i++) {
            List<Integer> row = new LinkedList<>();
            for (int j = 0; j < i + 1; j++) {
                if (j == 0 || i == j) {
                    row.add(1);
                } else {
                    row.add(list.get(i - 1).get(j - 1) + list.get(i - 1).get(j));
                }
            }
            list.add(row);
        }
        return list;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numRows = scanner.nextInt();
        List<List<Integer>> list = generate(numRows);
        for (int i = 0; i < numRows; i++) {
            for (int j = 0; j < i + 1; j++) {
                System.out.print(list.get(i).get(j) + " ");
            }
            System.out.println();
        }
    }
}

 运行结果图：

一只淡水鱼66
关注
专栏目录
初识线性表-顺序表以及ArrayList常见用法
qq_45860824的博客
03-24 238
认识线性表和顺序表以及java中的用法线性表和顺序表二级目录三级目录 线性表和顺序表 线性表（linear list）：是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 线性表 1.顺序表（逻辑上线性，在内存中存储时，也是严格按照逻辑上的次序保存起来的） 2.链表（逻辑上线性，在内存中存储
【Java数据结构】初始线性表之一：链表
yican2580的博客
07-17 3212
本章节介绍了线性表中的链表以及如何模拟实现一个链表，并且介绍了Java中链表的一些常见的方法
初识数据结构之线性表_Java（顺序表、单向链表、双向链表、栈、队列）
Mats的博客
04-20 641
线性表 概念 线性表是一种最为常见的数据结构，其特点是前后元素具有一对一的对应关系，除了第一个元素和最后一个元素以外，其他元素有且仅前边有一个前驱元素，后边有一个后继元素。 线性表的分类 按照存储结构分为顺序表与链表 线性表通用接口 /** * 线性表通用接口 * @author : LiangJie * @date : 2022/4/20 20:55 */ public interface Linear<T> { // 清空当前线性表 void clear
实验一 线性表的顺序存储与实现_java实现：初识链表
weixin_39703773的博客
10-22 88
今天来谈谈链表数组与链表分别属于线性表的两种基本存储结构：顺序存储结构和链式存储结构。顺序存储结构：用一段地址连续的存储单元依次存储线性表的数据元素。链式存储结构：地址可以连续也可以不连续的存储单元存储数据元素。链式存储结构包括单链表，双链表，循环链表。链表优劣势：使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组...
数据结构专题——线性表之顺序表及其Java实现
Jesmin的CSDN博客
10-31 528
在上一篇博客中，博主为大家介绍了关于数据结构的三个基本概念：数据结构，数据类型，抽象数据类型。在本篇博客中，博主将为大家介绍本系列中第一个出场的数据结构——线性表。顾名思义，线性表就是一种具有像线一样性质的表。比如在操场上站成一列的学生们，总有一个打头，一个结尾，中间的任何一个学生都知道自己前一名同学是谁和后一名同学是谁，就像有一根线将他们串了起来一样。
数据结构(一):线性表的实现
weixin_50600369的博客
09-06 622
线性表的顺序存储及其实现1.初识顺序表定义线性表的地址计算公式顺序表的特点2.顺序表的实现(Java语言描述)创建顺序表的功能实现的接口实现接口实现类的构造方法置空表判断是否为空获取表长度得到某个位置的元素插入元素删除元素查找功能输出线性表中的元素实现类代码汇总3.测试4.算法性能分析（考虑移动元素的平均情况）插入操作删除操作总结 1.初识顺序表 定义 所谓顺序表,就是顺序存储的线性表,是最简单的数据结构。顺序存储是用一组地址连续的存储单元依次存放线性表中的各个数据元素的存储结构,如下图: 线性表的地址计
【Java学习及数据结构初识】顺序表和链表【详解篇10】
m0_59157222的博客
09-02 357
文章目录一、线性表二、顺序表概念及结构接口实现顺序表接口的实现代码顺序表接口的测试代码测试打印结果三、链表什么是链表？带头结点的单向非循环链表带头节点的单向循环链表不带头节点的单向非循环列表如何产生一个节点？△头插法addFirst方法△尾插法addLast方法△任意位置插入addIndex方法查找是否包含关键字key是否在单链表当中 contains方法△删除第一次出现关键字为key的节点 remove方法△删除所有值为key的节点removeAllKey方法得到单链表的长度 size方法打印单链表dis
【javaSE】初识数据结构，顺序表和链表（一）
weixin_52134286的博客
12-12 1273
内容介绍1 线性表2 顺序表2.1 概念与结构2.2 顺序表相关问题3 链表3.1 初识链表 1 线性表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。 2 顺序表 2.1 概念与结构 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结
数据结构—笔记整理—初识数据结构
热门推荐
好好读书
10-22 4万+
数据结构笔记及相关知识整理，冲冲冲！！！
从零开始带你学习Java中的数据结构之Arrays/ArrayList精析
匿名王同学的博客
07-27 275
  最近很多小伙伴烦恼，自己刷题对数据结构一无所知，看见leetcode心生胆怯，或者你仅仅在课本上学过数据结构，但不知如何应用到实际的Java代码中，你的福音来啦，现在我们开始从零学习数据结构，助你一步登天！！ 注：以下所有讨论基于jdk1.8版本 1.初识数据结构2.jdk1.8--Arrays数组2.1Arrays数组简介2.2.如何创建Arrays数组2.3Arrays数组常用方法3.jdk1.8--ArrayList数组3.1ArraysList数组简介3.2.如何创建ArrayList数组3
Java实现基本数据结构（三）——队列
星如月的博客
03-01 406
  在数据结构中，队列和栈（[Java实现基本数据结构（二）——栈](https://blog.csdn.net/qq_42764725/article/details/104585079)）类似，也是一种线性表的结构。不同的地方在于栈只允许数据从一端进行插入和删除，而队列（Queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。根据这一种操作限制，我们将队列入队（插入操作）的一端称为队尾，出队（删除操作）的一端称为队首。所以队列也被称作为先进先出表（FIFO：First
数据结构复习题
weixin_52093131的博客
01-02 2439
文章目录数据结构 复习题填空选择判断简答存储结构森林阿克曼（Ackerman）函数排序直接选择排序：冒泡排序： 数据结构 复习题 填空 在数据结构中, 从逻辑上能够把数据结构分为 线性结构 非线性结构 数据结构在计算机内存中的表示是指 数据的存储结构 链式存储的特点是利用**指针** 来表示数据元之间的逻辑关系。 对于给定的n个元素，可以构造出的逻辑结构有 集合 树形结构 线性结构 图结构 顺序存储结构是通过==结点物理上相邻==表示元素之间的关系的；
认识数据结构
Java-面试
04-27 572
一、数据结构的定义 数据结构是带有结构特性的数据元素的集合，它研究的是数据的[逻辑结构]和数据的物理结构以及它们之间的相互关系，并对这种结构定义相适应的运算，设计出相应的算法，并确保经过这些运算以后所得到的新结构仍保持原来的结构类型。 简而言之，数据结构是相互之间存在一种或多种特定关系的数据元素的集合，即带“结构”的数据元素的集合。“结构”就是指数据元素之间存在的关系，分为逻辑结构和存储结构。 数据的逻辑结构和物理结构是数据结构的两个密切相关的方面，同一逻辑结构可以对应不同的存储结构。算法的设计取决于数据
数据结构——顺序存储结构（栈）
weixin_45432742的博客
09-12 540
在之前基础的介绍中，我有写过一篇关于栈的内容（https://blog.csdn.net/weixin_45432742/article/details/99850913），介绍了栈以链表实现的方法和以以数组实现的方法，但是实现的栈将其存储的数据类型限制了，只能存储int类型的数据。在这里，再优化一下，加入泛型，并用顺序表实现一个栈结构，并且将其扩展，变成一个双端栈结构。 栈 栈是限定仅在表尾...
spring事务详细讲解-深入浅出
小电玩
09-08 533
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1517
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
Java集合：Stack详解
最新发布
yang_brother的博客
09-10 580
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 613
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
评论 72
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值