知识改变命运 数据结构【顺序表】

最新推荐文章于 2024-09-15 11:59:30 发布
最新推荐文章于 2024-09-15 11:59:30 发布
阅读量1.1k 收藏 14
点赞数 29
分类专栏： 数据结构(Java版) 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_84062064/article/details/141023909
版权

1.线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结
构，常见的线性表：顺序表、链表、栈、队列…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物
理上存储时，通常以数组和链式结构的形式存储。
在这里插入图片描述

2.顺序表

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

2.1 接口的实现

public class SeqList {
    private int[] array;
    private int size;
    // 默认构造方法
    SeqList(){ }
    // 将顺序表的底层容量设置为initcapacity
    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() { }
}

代码实现：

public class MyListArray implements List{
    public  int []elme;
    public int ussize=0;
    public MyListArray (){
       this.elme  =new int[2];
    }

    /**
     * 把data放在数组中 有效数据的最后一个
     * @param data
     */
    @Override

    public void add(int data) {
        if(isFull()){
            resize();
        }
        elme[ussize]=data;
        ussize++;
    }

    public void resize(){
       elme=Arrays.copyOf(elme,2*(elme.length));
    }

    /**
     * 将data放在数组pos的位置;
     * @param pos
     * @param data
     */
    @Override
    public void add(int pos, int data) {
        if (isFull()){
            this.resize();
        }
        if(pos<0||pos>ussize){
            throw new RuntimeException("pos位置不合法");
        }
        for (int i = ussize-1; i>=pos ; i--) {
            this.elme[i+1] =this.elme[i];
        }
        elme[pos]=data;
        ussize++;
    }

    /**
     * 找到tofind数据返回ture或flase
     * @param toFind
     * @return
     */
    @Override
    public boolean contains(int toFind) {
        for (int i = 0; i <ussize-1 ; i++) {
            if(toFind==elme[i]){
                return true;
            }
        }
        return false;
    }
    /**
     * 找到tofind数据返回下标
     * @param toFind
     * @return
     */
    @Override
    public int indexOf(int toFind) {
        for (int i = 0; i <ussize-1 ; i++) {
            if(toFind==elme[i]){
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取下表的值
     * @param pos
     * @return
     */
    @Override
    public int get(int pos) {
        if(pos<0||pos>=ussize){
            throw new RuntimeException("pos位置不合法");
        }
        return elme[pos];
    }

    /**
     * 更新pos下标的值为value
     * @param pos
     * @param value
     */
    @Override
    public void set(int pos, int value) {
        if(pos<0||pos>=ussize){
            throw new RuntimeException("pos位置不合法");
        }
        this.elme[pos]=value;
    }

    @Override
    public void remove(int toRemove) {
        int index=indexOf(toRemove);
        if(index==-1){
            return;
        }
        for (int i =index; i <ussize-1 ; i++) {
            elme[i]=elme[i+1];
        }
        ussize--;
    }
    public void removeALl(int toRemove) {
        for (int i = 0; i <ussize ; i++) {
            if(elme[i]==toRemove){
                for (int j =i; j <ussize ; j++) {
                    elme[j]=elme[j+1];
                }
                ussize--;
                i--;
            }
        }

    }

    @Override
    public int size() {
        return this.ussize;
    }

    /**
     * 删除所有数据
     */
    @Override
    public void clear() {
//        for (int i = 0; i < ussize; i++) {
//            elme[i]=null;
//        }如果是引用类型
        ussize=0;
    }

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

    @Override
    public boolean isFull() {
        return ussize==elme.length;
    }
}

3. ArrayList简介

在集合框架中，ArrayList是一个普通的类，实现了List接口，具体框架图如下：
在这里插入图片描述

【说明】

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

4. ArrayList使用

4.1 ArrayList的构造

在这里插入图片描述

public static void main(String[] args) {
	// ArrayList创建，推荐写法
	// 构造一个空的列表
	List<Integer> list1 = new ArrayList<>();
	// 构造一个具有10个容量的列表
	List<Integer> list2 = new ArrayList<>(10);
	list2.add(1);
	list2.add(2);
	list2.add(3);
	// list2.add("hello"); // 编译失败，List<Integer>已经限定了，list2中只能存储整形元素
	// list3构造好之后，与list中的元素一致
	ArrayList<Integer> list3 = new ArrayList<>(list2);
	// 避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难
	List list4 = new ArrayList();
	list4.add("111");
	list4.add(100);
}

4.2 ArrayList常见操作

ArrayList虽然提供的方法比较多，但是常用方法如下所示，需要用到其他方法时，同学们自行查看ArrayList的帮助
文档

boolean add(E e) 尾插 e

void add(int index, E element) 将 e 插入到 index 位置

boolean addAll(Collection<? extends E> c) 尾插 c 中的元素

E remove(int index) 删除 index 位置元素

boolean remove(Object o) 删除遇到的第一个 o

E get(int index) 获取下标 index 位置元素

E set(int index, E element) 将下标 index 位置元素设置为 element

void clear() 清空

boolean contains(Object o) 判断 o 是否在线性表中

int indexOf(Object o) 返回第一个 o 所在下标

int lastIndexOf(Object o) 返回最后一个 o 的下标

List<E> subList(int fromIndex, int toIndex) 截取部分 list

public static void main(String[] args) {
	List<String> list = new ArrayList<>();
	list.add("JavaSE");
	list.add("JavaWeb");
	list.add("JavaEE");
	list.add("JVM");
	list.add("测试课程");
	System.out.println(list);
	// 获取list中有效元素个数
	System.out.println(list.size());
	// 获取和设置index位置上的元素，注意index必须介于[0, size)间
	System.out.println(list.get(1));
	list.set(1, "JavaWEB");
	System.out.println(list.get(1));
	// 在list的index位置插入指定元素，index及后续的元素统一往后搬移一个位置
	list.add(1, "Java数据结构");
	System.out.println(list);
	// 删除指定元素，找到了就删除，该元素之后的元素统一往前搬移一个位置
	list.remove("JVM");
	System.out.println(list);
	// 删除list中index位置上的元素，注意index不要超过list中有效元素个数,否则会抛出下标越界异常
	list.remove(list.size()-1);
	System.out.println(list);
	// 检测list中是否包含指定元素，包含返回true，否则返回false
	if(list.contains("测试课程")){
	list.add("测试课程");
	}
	// 查找指定元素第一次出现的位置：indexOf从前往后找，lastIndexOf从后往前找
	list.add("JavaSE");
	System.out.println(list.indexOf("JavaSE"));
	System.out.println(list.lastIndexOf("JavaSE"));
	// 使用list中[0, 4)之间的元素构成一个新的SubList返回,但是和ArrayList共用一个elementData数组
	List<String> ret = list.subList(0, 4);
	System.out.println(ret);
	list.clear();
	System.out.println(list.size());
}

我们要强调下上面方法中的：
E remove(int index)
boolean remove(Object o)
当我们要删掉1时候，会发现是删掉的是下标1的数值所以我们要这样去写
在这里插入图片描述

4.3 ArrayList的遍历

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

ArrayList<Integer> list=new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
        System.out.println("=======for循环========");
        for (int i = 0; i <list.size() ; i++) {
            System.out.print(list.get(i));
        }
        System.out.println();
        System.out.println("=======for each 循环========");
        for (Integer x: list) {
            System.out.print(x);
        }
        System.out.println("=======迭代器遍历1========");
        Iterator<Integer> it= list.iterator();
        while(it.hasNext()){
            System.out.print(it.next()+" ");
        }
        System.out.println();
        System.out.println("=======迭代器遍历2========");
        ListIterator it1=list.listIterator();
        while (it1.hasNext()){
            System.out.print(it1.next());
        }
        System.out.println();
        System.out.println("=======迭代器遍历3========");
        ListIterator it2=list.listIterator(list.size());
        while (it2.hasPrevious()){
            System.out.print(it2.previous());
        }
        System.out.println();

4.4 ArrayList的扩容机制

下面代码有缺陷吗？为什么？

  public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            list.add(i);
        }
    }

ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容。以下是ArrayList源码中扩容方式：

Object[] elementData; // 存放元素的空间
     private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认空间
     private static final int DEFAULT_CAPACITY = 10; // 默认容量大小
     public boolean add(E e) {
         ensureCapacityInternal(size + 1); // Increments modCount!!
         elementData[size++] = e;
         return true;
     }
     private void ensureCapacityInternal(int minCapacity) {
         ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
     }
     private static int calculateCapacity(Object[] elementData, int minCapacity) {
         if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
             return Math.max(DEFAULT_CAPACITY, minCapacity);
         }
         return minCapacity;
     }
     private void ensureExplicitCapacity(int minCapacity) {
         modCount++;
// overflow-conscious code
         if (minCapacity - elementData.length > 0)
             grow(minCapacity);
     }
     private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
     private void grow(int minCapacity) {
// 获取旧空间大小
         int oldCapacity = elementData.length;
// 预计按照1.5倍方式扩容
         int newCapacity = oldCapacity + (oldCapacity >> 1);
// 如果用户需要扩容大小 超过 原空间1.5倍，按照用户所需大小扩容
         if (newCapacity - minCapacity < 0)
             newCapacity = minCapacity;
// 如果需要扩容大小超过MAX_ARRAY_SIZE，重新计算容量大小
         if (newCapacity - MAX_ARRAY_SIZE > 0)
             newCapacity = hugeCapacity(minCapacity);
// 调用copyOf扩容
         elementData = Arrays.copyOf(elementData, newCapacity);
     }
     private static int hugeCapacity(int minCapacity) {
// 如果minCapacity小于0，抛出OutOfMemoryError异常
         if (minCapacity < 0)
             throw new OutOfMemoryError();
         return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
     }

上面jdk8的扩容机制
【总结】

  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小
    初步预估按照1.5倍大小扩容
    如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
    真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  3. 使用copyOf进行扩容
    缺陷：对空间有一定的浪费。
代阳的专属博客
关注
专栏目录
Spring Boot进阶(36)：YAML、Properties配置文件轻松实现List数据读取
**My Coding Family**
10-29 8798
yml、properties两种配置文件list写法及数据读取，一文教会你。
2020年java知识总结
知识改变命运，ヾ(◍°∇°◍)ﾉﾞ【求关注】
02-21 461
1.程序运行时如果需要创建数组等数据结构，操作系统就会在进程的堆空间申请一块相应的内存空间，并把这块内存的首地址信息记录在进程的栈中。 2.堆是一块无序的内存空间，任何时候进程需要申请内存，都会从堆空间中分配，分配到的内存地址则记录在栈中。 3.栈是严格的一个后进先出的数据结构，同样由操作系统维护，主要用来记录函数内部的局部变量、堆空间分配的内存空间地址等。 4.系统为什么会变慢，为什么会崩溃 现...
Arraylist的个人理解
m0_65054279的博客
04-24 319
Arraylist的个人理解 所谓Arraylist,我的理解就是它是一个动态的可灵活变更大小的数组，或者是叫动态数组，它允许任何元素的插入，包括null，它的特点是：有序的(按照添加的顺序),不唯一：同一个元素可以装多次。 它的初始化容量为10，如果增加元素大于10，那么它就会进行扩容操作 private static final Object[] EMPTY_ELEMENTDATA = {}; transient Object[] elementData;//源码中有多处表示它是一个数组 t
关于对Arraylist的初步认识
m0_65431718的博客
10-04 217
对Arraylist和线性表的初步认识
简单谈谈对ArrayList集合的理解
Luisc_的博客
06-20 646
ArrayList集合底层为数组式结构，所以是有序的集合并且可以重复，可以根据下标进行取值，是非线程安全的。 ArrayList集合在调用无参构造方法实例化的时候，并没有创建数组，而是在用户第一次执行添加的时候进行创建数组，ArrayList的添加方法，先进行判断数组是否已创建，如果没创建先创建数组，然后调用扩容方法grow，将数组当前的长度+1的值一并传到grow方法中，ArrayLis...
判读一个对象不为空_ArrayList实现分析（一）——对象创建
weixin_39756273的博客
12-02 254
ArrayList是java中最常用的集合类之一，它的内部实现是基于数组，因此ArryList可以根据索引实现随机访问。ArryList继承了AbstractList类，并且实现了List, RandomAccess, Cloneable接口。下面详细分析一下ArrayList的实现，下面的分析是基于JDK1.8版本。ArrayList对象创建ArryList有三个构造函数：//创建一个默认大小的...
ArrayList函数及相关解释(一)
hongbochen1223的专栏
08-14 1351
Java中ArrayList是使用对象数组实现的，默认的数组容量为10。在ArrayList中，默认创建了两个空的对象数组，一个用户该对象的空实例，一个用于当第一个元素被添加的时候，该数组要被填充多少。 同时，该类中还有一个transient属性的对象数组，transient描述的对象属性，表示在序列化的时候，不用去序列化该属性。 1、ArrayList构造函数 首先我们看一下ArrayList的构造函数，该类有三个构造函数，分别是： ArrayList(int initialCapacity) Arra
数据结构链表的操作
TY113322的博客
03-16 1385
一.链表 1.单链表逆置 解题思路： 使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ret 此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。 同时让当前结点的 next 指针指向 NULL ，从而实现从链表尾部开始的局部反转 当递归函数全部出栈后，链表反转完成。 递归实现版: 非递归实现版本解题思路： 定义两个指针： pre 和 cur ；pre 在前 cur 在后。 每次让 pre 的 next 指向 cur ，实现一次局部反转 局部反转
Python 编程1000例(10)：以当前日期时间批量创建文件及实现字符串与列表等数据的去重案例
Amo Xiang的博客
01-27 1641
文章目录一、以当前日期时间批量创建文件二、实现字符串与列表等数据的去重 本系列文章通过 1000（一篇文章表示 1 个实例） 个实例 ，为读者提供较为详细的练习题目，以便读者举一反三，深度学习。本系列的文章涉及到 Python 知识点包括：Python 语言基础、运算符和表达式、语句和程序结构、列表和元组、字典和集合、字符串、正则表达式、函数、面向对象编程、模块和包、异常处理和程序调试、文件和目录操作、数据库编程、界面编程、网络编程、WEB 编程、进程和线程、网络爬虫、游戏编程等知识点，由易到难，由浅入深，
【Java程序员面试专栏 Java领域】Java虚拟机 核心面试指引
MaoLin Tian's Blog
02-17 411
将*.java文件转为*.class的过程称为编译器的前端（前端编译例如：JDK的javac编译器当虚拟机发现某个方法或代码块运行特别频繁时，就会把这些代码认定为“Hot Spot Code”（热点代码），为了提高热点代码的执行效率，在运行时，虚拟机将会把这些代码编译成与本地平台相关的机器码，并进行各层次的优化，完成这项任务的正是JIT编译器，把字节码(*.class文件) 转变为本地机器码的过程称为Java虚拟机的即时编译运行期（JIT编译器，Just In Time）
ArrayList的详解
m0_53677355的博客
10-04 5199
线性表在逻辑上是线性结构，也就是说是连续的一条直线，但是在物理上不一定是连续的，线性表在物理上存储的时候，通常以数组和链式结构的形式存储，常见的线性表：顺序表、链表、栈、队列...顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删查改。1）调用无参构造方法，初始化ArrayList对象，底层创建了一个空数组，第一次add的时候才去指定数组的容量。6、ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表。
ArrayList的理解
ZhaFi人
09-26 3408
ArrayList集合是Collection和List接口的实现类，底层的数据结构可变的Object数组，对ArrayList的所有操作都是通过数据来实现的，数据结构特点是增删慢、查询快。// 默认的容量大小（常量）// 定义的空数组（final修饰，大小固定为0）// 定义的默认空容量的数组（final修饰，大小固定为0）// 定义的不可被序列化的数组，实际存储元素的数组// 数组中元素的个数。
List＜String＞ list=new ArrayList＜String＞()的意思
qq_42514371的博客
03-15 7356
** List list=new ArrayList()的意思 ** List是集合最大的父类，它包含了ArrayList。 如果直接声明为ArrayList list=new ArrayList()这个也没有问题。 而声明成:List list=new ArrayList();这样的形式使得list这个对象可以有多种的存在形式，比如要用链表存数据的话直接用LinkedList，使用ArrayList或者Vector直接通过list去=就可以了，这样让list这个对象活起来了，“有甚麼大问题呢？只不过是多一
List＜Integer＞ list = new ArrayList＜＞()里面可以放String类型的数据吗？
熊二吃屁的博客
10-08 1443
可以通过反射将String放入List中。 那什么是反射呢？ 在运行过过程中 获取类的名称，方法，属性，注解，类型等。 获取任意对象的方法，属性等。并且可以改变对象属性 判断一个对象所属的类 实例化任意一个类的对象 其实就是java提供的reflect包 回到一开始的那个问题，List list = new ArrayList<>()里面可以放String类型的数据吗？ 很显然是可以的，因为list是一个对象，而反射可以获取对象的属性方法，并且改变对象属性。那我们就可以通过list.getM
21_动态规划与数据结构结合
刘炫320的博客
09-11 518
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 942
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
[数据结构]二叉搜索树
最新发布
2302_80220453的博客
09-15 540
今天我们来学习一下新的数据结构，二叉搜索树，这个结构比较简单，是一个铺垫式的结构，为之后的平衡二叉树，AVL树以及红黑树做一个知识基础，我们将从概念到实现具体的介绍二叉搜索树。
数据结构 - 链表
kaneki_lh的博客
09-11 485
listnode;/* 双向链表结构体 */}dlinklist;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值