【JAVA】顺序表与ArrayList

最新推荐文章于 2024-09-04 21:44:11 发布
最新推荐文章于 2024-09-04 21:44:11 发布
阅读量506 收藏
点赞数
分类专栏： Note-数据结构 文章标签： java 数据结构 链表 顺序表 ArrayList
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54150521/article/details/126027125
版权

顺序表与ArrayList

顺序表与ArrayList

坚持一定很酷！

学习学习！！

一、线性表

  1. 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…
  2. 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构（内存上）上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
  3. 数据结构当中，每次插入数据的时候，一定要有一个前驱信息。
    不能跳着放置元素！！
  4. 增删查改：CURD

二、顺序表

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

接口的实现

  1. 相关实现：
  1. 判断数组是否已经放满：有效长度==实际数组长度。
    扩容：数组名 = Arrays.copyOf(数组名,扩容后的长度)
    一般情况下，扩容不会失败；但是如果扩容的数据太大，可能就会无法扩容，就会报负数异常：所以可以try…catch 再进行异常处理。
  2. 注意插入元素操作：
    把usedSize-1位置的元素向后挪，一直到想要插入的
    pos位置;（>=pos)的元素都向后挪，再把元素插入到
    pos位置
  3. add(int pos,int data):首先检查元素是否合法，然后
    再判断是否满以及扩容问题，最后进行插入操作
    add(int data):先判断是否满，然后进行扩容，然后再
    进行尾插（usedSize位置插入）
  4. 是否包含contains：for循环usedSize
  5. 基本上都要判断下标合法性
    remove():后一个覆盖前一个，然后最后一个元素置空
    则：for循环只到 (<usedSize-1)；最后将usedSize进行–
  6. 删除等操作要进行手动置空（尤其是引用类型），简单类型可以不写
  7. 向右移>>1 :表示除以2
  8. 注意联动改变（子串与原来字符串)
  1. 代码模拟实现相关方法：
  • SeqList.java
package arraysList;


import java.util.Arrays;

// 顺序表以数组形式进行存储
public class SeqList {
    // 首先创建必要的量：数组、有效数记录、默认数组长度
    public int[] array;
    public int usedSize;
    public static final int DEFAULT_SIZE = 5;

    // 构造方法进行初始化（初始化数组大小，为数组开辟空间）
    public SeqList() {
        array = new int[DEFAULT_SIZE];
    }

    // 不采用以下方法，采用报异常的方式！！
    /*// 检查下标的合法性：不能跳着进行存放
    public boolean isLegal(int pos) {
        if((pos<0)||(pos>usedSize)) {
            return false;
        } else {
            return true;
        }
    }*/

    // 检查下标的合法性：不能跳着进行存放
    // 抛出异常以及自定义异常
    public void isLegal(int pos) {
        if((pos<0)||(pos>usedSize)) {
            throw new PosIndexNotLegalException("下标不合法！");
        }
    }

    // 判断是否满
    public boolean isFull() {
        return (this.usedSize == array.length);
    }

    // 打印顺序表-打印有效位即可
    public void display() {
        /* // 使用for-each进行打印-no-因为会全部打印！！
        for (int x:array) {
            System.out.println(x);
        }*/

        // 尽量使用this！！！
        for (int i = 0; i < this.usedSize; i++) {
            System.out.print(this.array[i] + " ");
        }
        System.out.println();
    }

    // 新增元素,默认在数组最后新增
    public void add(int data) {
        // 判断是否已满
        try {
            if(isFull()) {
                array = Arrays.copyOf(array,-1);
            }
        } catch (NegativeArraySizeException e) {
            e.printStackTrace();
            array = Arrays.copyOf(array,2*array.length); //扩容两倍
        }
        // 在usedSize位置进行元素存储，然后usedSize++
        array[usedSize++] = data;
    }

    // 在 pos 位置新增元素
    public void add(int pos, int data) {
        // 检查pos是否合法--try...catch方式
        // 判断是否满以及扩容
        // 将pos以及之后的位置全部向后挪一位:注意应该从后往前挪！！
        try {
            isLegal(pos);
            if(isFull()) { // 满了就扩容，不需要进行异常抛出
                array = Arrays.copyOf(array,2*array.length);
            }
            for (int i = usedSize-1; i >= pos; i++) {
                array[i+1] =array[i];
            }
            array[pos] = data;
            usedSize++; // 更新有效数据个数
        } catch (PosIndexNotLegalException e) {
            e.printStackTrace();
        }
    }

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
        // 进行遍历
        for (int i = 0; i < usedSize; i++) {
            if(array[i] == toFind) {
                return true;
            }
        }
        return false;
    }

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
        // 进行遍历
        for (int i = 0; i < usedSize; i++) {
            if(array[i] == toFind) {
                return i;
            }
        }
        return -1; // 不存在就输出-1
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
        // 首先判断pos是否合法
        // 合法且找到才输出元素
        try {
            isLegal(pos);
            return array[pos];
        } catch (PosIndexNotLegalException e) {
            e.printStackTrace();
        }
        return -1;
    }

    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
        // 首先进行合法性判断，然后将pos位置的元素进行替换
        try {
            isLegal(pos);
            array[pos] = value;
        } catch (PosIndexNotLegalException e) {
            e.printStackTrace();
        }
    }

    //删除第一次出现的关键字key
    public void remove(int toRemove) {
        // 遍历的方法不容易进行覆盖操作，则改用找该元素的首下标，找到就存在可以进行覆盖，否则不存在不用删除
        /*//遍历
        for (int i = 0; i < usedSize; i++) {
            if(array[i]==toRemove) {
                // 从该项开始进行覆盖，一直到usedSize-1

            }
        }*/

        // 改用找该元素的首下标，找到就存在可以进行覆盖，否则不存在不用删除
        int index = indexOf(toRemove);
        if(index == -1) {
            System.out.println("sorry 该关键字并不存在！");
            return;
        } else {
            // 从该项开始进行覆盖，一直到usedSize-1: 从前往后+usedSize--
            for (int i = index; i < usedSize-1; i++) {
                array[i] = array[i+1];
            }
        }
        // 有效元素--
        usedSize--;
    }

    // 获取顺序表长度：有效长度
    public int size() {
        return usedSize;
    }

    // 清空顺序表
    public void clear() {
        /*for (int i = 0; i < usedSize; i++) {
            array[i] = Integer.parseInt(null);
        }*/

        // 将有效个数置0就行
        usedSize = 0;
        System.out.println("清空成功！");
    }

}
  • PosIndexNotLegalException.java
package arraysList;

// 自定义下标不合法异常-非受查异常-运行时异常
public class PosIndexNotLegalException extends RuntimeException{
    public PosIndexNotLegalException() {
    }

    public PosIndexNotLegalException(String message) {
        super(message);
    }
}
  • 测试代码可以自己写

三、ArrayList简介

  1. 在集合框架中，ArrayList是一个普通的类，实现了List接口
  2. 说明：
  1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
  2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
  3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
  4. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者CopyOnWriteArrayList
  5. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表
  1. 小结ArrayList：
    支持随机访问、可克隆、支持序列化、非线程安全（单线程）、动态类型（底层连续、可动态扩容）。

四、ArrayList使用

1. ArrayList的构造

ArrayList

2. ArrayList的常见操作

方法

3. ArrayList的遍历

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

// 掌握ArrayList的常用方法
// ArrayList的遍历：三种方式

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Test {
    public static void main(String[] args) {
        //List<Integer> list = new List<>();  //错误！List是接口，不能进行实例化！！但是可以对具体子类进行初始化

        List<Integer> list = new ArrayList<>();
        // 增加元素！
        list.add(12);
        list.add(34);
        list.add(2,56);
        list.add(78);
        list.add(4,90);

        // for循环+下标进行遍历:注意获取长度的方法
        System.out.println("使用for循环+下标进行遍历：");
        for (int i = 0; i < list.size(); i++) {
            // 注意获取下标对应元素的方法
            System.out.print(list.get(i)+" ");
        }
        System.out.println();

        // 使用for-each进行遍历：
        System.out.println("使用for-each进行遍历：");
        for (int x:list) {
            System.out.print(x+" ");
        }
        System.out.println();

        // 使用迭代器遍历
        // 使用ListIterator
        System.out.println("使用ListIterator迭代器遍历（调用List方法）：");
        ListIterator<Integer> listIterator = list.listIterator(); // 一定要注意该处的赋值内容是调用List的方法！！
        while(listIterator.hasNext()) {
            System.out.print(listIterator.next()+" ");
        }
        System.out.println();

        // 使用Iterator
        System.out.println("使用Iterator迭代器遍历（调用List方法）：");
        Iterator<Integer> iterator = list.iterator(); // 一定要注意该处的赋值内容是调用List的方法！！
        while(iterator.hasNext()) {
            System.out.print(iterator.next()+" ");
        }
        System.out.println();
    }
}
  1. 迭代器遍历数组
  • Iterator<类型如：String> it = list.iterator();
    while(it.hasNext()) { sout(it.next());}
  • ListIterator<类型如：String> it = list.listIterator();
    while(it.hasNext()) { sout(it.next());}

4. ArrayList的扩容机制

  1. ArrayList是一个动态类型的顺序表，即：在插入元素的过程中会自动扩容。
  2. 根据ArrayList源码总结扩容方式：
  1. 检测是否真正需要扩容，如果是调用grow准备扩容
  2. 预估需要库容的大小
    初步预估按照1.5倍大小扩容
    如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
    真正扩容之前检测是否能扩容成功，防止太大导致扩容失败
  3. 使用copyOf进行扩容
  • grow方法补充：
// 扩容
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);
}

五、使用实例

1. 扑克牌

  1. 关键点
  1. 进行洗牌：
    随机数！！注意Random进行实例化的过程。
  2. 抓牌过程要注意双层循环的顺序：
    是先给每个人都发一张牌，而不是给一个人先发完五张牌
    so：
    顺序为：先进行5张牌循环，再进行3个人循环，这样才会
    使得先给三个人每人一张牌，即用牌去循环人
  1. 代码
  • Card.java
package card;

// 首先准备一副牌的必要变量
public class Card {
    public int value;  // 牌面值
    public char flower; //花色

    // 构造方法进行初始化


    public Card(int value, char flower) {
        this.value = value;
        this.flower = flower;
    }

    // toString 方法进行重写
    @Override
    public String toString() {
        return "{" + value  + flower +
                "}";
    }
}
  • CardDemo.java
package card;

// static只有一份，要改变就全部改变！

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

// 具体牌以及洗牌、出牌
public class CardDemo {
    // 先给花色创建一个组-类似常数！！
    public static final char[] SUITS = {'♥','♠','♦','♣'};

    // 准备一副牌
    // 注意每一张牌都是由花色以及牌面值组成的，也就是一个Card类型--所以使用List，以Card类型作为参数！

   // List<Card> list = new ArrayList<>();// 注意该处进行修改，写为以下形式

    private static List<Card> preDesk() { // 直接写为一个方法，返回值类型是List<Card>（整副牌）
        List<Card> desk = new ArrayList<>(52);  // 容量52:52张牌
        // 进行牌的初始化
        for (int i = 0; i < 4; i++) {
            for (int j = 1; j <= 13; j++) {
                Card card = new Card(j,SUITS[i]);
                // 每初始化一张牌就把牌存储添加到desk里面（这副牌）
                desk.add(card);
            }
        }
        return desk;
    }

    // 进行洗牌 的实际操作
    private static void washDeskWork(List<Card> deck,int i, int j) {
        // 随机洗牌
        Card fa = deck.get(j);
        deck.set(j, deck.get(i));
        deck.set(i,fa);
    }

    // 创建随机数 +洗牌
    private static void washDesk(List<Card> deck) {
        Random random = new Random(20220728); //种子数
        for (int j = 1; j < deck.size(); j++) { //通过的是下标去打乱顺序，所以注意下标取值！
            // 注意输入的j只能从1开始！！！
            int i = random.nextInt(j);
            // i代表随机下标  j代表该牌的实际位置下标
            // 每获得一次随机位置就进行一次洗牌
            washDeskWork(deck,i,j);
        }
    }

    // 进行抓牌
    private static List<List<Card>> hand(List<Card> deck) {
        // 假设有3个人，每个人5张牌
        // 3个人构成一个数组，而每个人受力的5张牌又是一个数组，
        // 每张牌的返回类型是Card，每一组牌/每个人的返回类型其实是List<Card>
        // 而这三个人和五张牌相当于二维数组--可以用List顺序表表示数组
        List<List<Card>> table = new ArrayList<>();

        table.add(new ArrayList<>());  // 二维数组中的其中一维进行第二维开辟开间
        table.add(new ArrayList<>());
        table.add(new ArrayList<>());

        for (int i = 0; i < 5; i++) { //牌给每人一张
            for (int j = 0; j < 3; j++) { // 人
                /*table.get(j).set(i, deck.remove(i)); //remove的下标是0 永远删除的都是第一个元素！*/

                // 是要将元素添加到table中，而不是设置修改元素，现在一个有效元素都没有！
                table.get(j).add(deck.remove(0)); //注意下标！
            }
        }
        return table;
    }

    public static void main(String[] args) {
        CardDemo cardDemo = new CardDemo();
        // 牌展示
        System.out.println("准备好的完整牌：");
        List<Card> desk = preDesk();
        for (Card x:desk) {
            System.out.print(x.toString() + " ");
        }
        System.out.println();

        System.out.println("洗牌后：");
        washDesk(desk);
        for (Card x:desk) {
            System.out.print(x.toString() + " ");
        }
        System.out.println();

        // 抓牌
        System.out.println("进行抓牌：");
        List<List<Card>> hands = hand(desk);

        // 余牌
        System.out.println("抓牌后的余牌为：");
        for (Card x:desk) {
            System.out.print(x.toString()+" ");
        }
        System.out.println();

        // 每个人的牌
        System.out.println("所抓的每个人的牌进行展示：");
        for (int i = 0; i < 3; i++) {
            System.out.println("第"+(i+1)+"个人的牌展示：");
            /*for (int j = 0; j < 5; j++) {
                System.out.print(hands.get(i).get(j) +" ");
            }
            System.out.println();*/

            System.out.println(hands.get(i)); //注意输出形式！！以一维数组形式进行输出
        }
    }
}

2. 杨辉三角

杨辉三角

  • 代码：（按照链接来）
public List<List<Integer>> generate(int numRows) {

        // List<List<Integer>>：实际意义是一个二维数组，也就是两个一维数组，元素类型是int类型
        // 每行第一个元素以及最后一个元素都是1，其余元素是上面两个元素之和

        // 一定要注意二维数组要进行两次实例化new操作
        List<List<Integer>> list = new ArrayList<>();
        List<Integer> ret = new ArrayList<>();

        ret.add(1);
        list.add(ret);// 第一行第一列搞定！

        // 从1一行开始是因为之前第一行已经搞定！
        for(int i=1; i<numRows; i++) {
            // 当前行-一维数组
            List<Integer> curRow = new ArrayList<>();
            curRow.add(1); // 当前每行第一列为1 ok！

            /// 上一行
            //List<Integer> preRow = new ArrayList<>(); // 错误，这样并未给其初始化！

            List<Integer> preRow = list.get(i-1); //注意！！

            // 从1开始是因为首列值已经确定，以及只有从1开始才能取到前一行的首列0列
            // 注意该处循环的次数！！
            //for(int j=1; j<numRows-1; j++) {

            // 需要使用上一行最后一列，因为计算需要，但是每行总会比上一行多一列，最后一列为1，需要后面单独拎出来add1
            for(int j=1; j<i; j++) {
                curRow.add(preRow.get(j-1)+preRow.get(j));  //取之前行的两列相加之和！
            }

            curRow.add(1); // 每行最后一列为1
            // 此时当前行就是完整一行了！
            list.add(curRow); // 再将当前行传入到二维数组
        }
        return list;


        // 以下是错误代码
       /* for(int i=0; i<numRows; i++) {
            list.get(i).add(1); // 如果要使用该种写法，就需要 list.add(new ArrayList<>());
            for(int j=1; j<numRows-1; j++) {
                int bef = list.get(i-1).get(j-1);
                int aft = list.get(i-1).get(j);
                list.get(i).add(j,(bef+aft));
            }
            list.get(i).add(numRows-1,1);
        }
        return list;*/
    }

六、顺序表问题以及思考

  1. 顺序表中间/头部的插入删除，时间复杂度为O(N)
  2. 增容需要申请新空间，拷贝数据，释放旧空间。会有不小的消耗。
  3. 增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
  4. 【问题小结】：
  • 顺序表的插入和删除，需要移动元素！
  • 扩容可能会造成空间浪费
  1. 基于以上问题：引出链表–将数据以链式的形式进行存储。
    顺序表是把元素以顺序进行存储的。

THINK

  1. 顺序表的常用方法
  2. ArrayList的使用以及遍历
  3. List的new！！
  4. List的使用场景：变量是以类型进行传入的
  5. 顺序表的实例！！
  6. 链表：链式存储 顺序表：顺序存储
'Dream是普通小孩耶
关注
专栏目录
Java顺序表模拟实现
weixin_50394543的博客
03-15 678
java中顺序表的模拟实现，泛型的简单运用。
顺序表与ArrayList
hlizoo的博客
08-17 260
万字详解带你全方面认识和使用ArrayList，并且在认识ArrayList前会带你了解线性表以及顺序表，还有Java集合类总图，更有ArrayList相关题目帮助你去明白ArrayList它的使用方式和使用场景
Java实现顺序表并实现动态扩容
Duktig的博客
02-05 740
背景 学习数据结构，必然要用一门语言将数据结构实现出来，一方面加深对数据结构的理解，另一方面可以了解这门语言实现数据结构的特点。 将数据结构Java实现总结下来，方便之后复习和间隔时间手撸代码 具体实现思路在Java的注释中写的已经很明显，不再做过多的阐述。实现方式使用动态数组来实现顺序表。 代码实现 public class SequenceList<E> { /** 存储对象的一维数组 */ private E[] data; /** 顺序表的元素个数 */
顺序表--Java版
迷路的小绅士之家
03-03 647
顺序表是一种基本的线性表结构，它通过数组来实现，支持快速随机访问元素，可以进行插入、删除操作。在实际应用中，顺序表被广泛地应用于常规数据结构、数据库系统以及算法设计等领域。在实现顺序表时，需要注意容量的扩展、元素的移动等问题，同时需要处理越界异常。
【JAVA数据结构】（ArrayList）顺序表
最新发布
2301_80038570的博客
09-04 1101
数据结构的顺序表——ArrayList的模拟实现，构造，使用，遍历，扩容机制，优缺点
【Java数据结构】ArrayList顺序表
Carefree_State的博客
02-28 1342
Java数据结构，ArrayList顺序表的模拟实现！！！详细解说，拓展八皇后，斗牛以及杨辉三角，集合类的基本使用以及一些源码的阅读！toArray()方法以及遍历方法的讲解！
Java数据结构之顺序表与ArrayList
fear_wolf的博客
10-02 426
例如：线性表是数据结构的第一部分，也是用的比较多的一部分知识，话不多说，开始卷ArrayList集合框架【说明】ArrayList 实现了 RandomAccess 接口，表明 ArrayList 支持随机访问ArrayList 实现了 Cloneable 接口，表明 ArrayList 是可以 clone 的ArrayList 实现了 Serializable 接口，表明 ArrayList 是支持序列化的。
Java顺序表与ArrayList对比分析：选型指南及性能决胜点
Java顺序表基础与ArrayList概述 在Java中，顺序表是一种重要的数据结构，它的实现类ArrayList是应用最广泛的数据结构之一。本章节将从基础的顺序表概念讲起，进而过渡到ArrayList的具体应用和使用场景。我们将细致...
java顺序表实验报告.docx
10-11
在实际应用中，Java 标准库提供了 `java.util.ArrayList` 类，它是一个更加完善的顺序表实现，包括更多的方法和优化，如线程安全性、迭代器支持以及对并发操作的支持。然而，这个实验报告中的实现提供了一个基础的...
java顺序表的基本操作.zip
12-17
Java顺序表是一种常见的数据结构，它在编程中扮演着重要的角色。这个压缩包"java顺序表的基本操作.zip"很可能包含了关于如何在Java中创建、操作和管理顺序表的相关示例和教程。顺序表通常指的是一个数组，其中元素...
Java - 数据结构之 顺序表与链表
m0_65638983的博客
12-25 585
假设当前有n个元素，第1个元素和第n个元素相等，第二个元素个第n-1个元素相等......直到中间只剩一个元素时(奇数个) 或者中间没有元素(偶数个)时称为回文这道题的思路又是好几个小题，首先是找出中间结点，其次反转中间结点后的链表，最后使用双指针从前后遍历即可力扣反转链表：力扣。
Python 每日一记229>>>Java顺序表扩容与缩容的实现
教练我想学编程
04-08 333
以下代码，只需要去查看扩容和缩容部分代码即可 /** * 线性表之顺序表的扩容和缩容 *在容量已满的情况下,添加元素会报错,这个时候可以扩容 * 本例中判断元素已满的情况下,如果还要添加元素,会将容量变为之前的两倍 * 在删除元素后,可能会造成容量的浪费,因此可以缩小容量 * 本例中删除元素后,判断如果元素个数小于容量的四分之一,则将容量变为之前的二分之一 * * 步骤: * 第一...
顺序表--增删查改（java)
xy199931的博客
07-23 234
头插  1. 需要从后往前遍历  2. 数据下标遍历范围 （红色标记 )[size-1,0]     空间下标遍历范围（蓝色标记） [size,1]  3. 搬移过程   array[空间下标]=array[数据]  4. 空间下标=数据下标+1 扩容  1. 扩容的条件    在插入之前，size = array.length  2.如何扩容（搬家）    1. 申请新房子（1.5 -...
java 数据结构之顺序表、ArrayList源码分析
xiaotanke
11-28 505
java 数据结构之顺序表 线性表是最简单的一种数据结构，一个线性表有n个具有相同特性的的数据元素的序列。 1、手写顺序表 前驱元素： 若A元素的前面是B元素，则称B是A的前驱元素。没有前驱元素的元素成为头结点。 后继元素： 若A元素的后面是B元素，则称B是A的后继元素。没有后继元素的元素成为尾结点。 通过存储方式的不同，可以将线性表分为两类，一类是顺序表，另一类是链表。 顺序表的基本实现： 属性 属性名 解释 默认值 elements[] 存放元素的数组 长度为5的一个泛型数组
Java顺序表和链表
xinhang10的博客
11-14 1877
此文章对Java数据结构中的顺序表和链表进行了十分细致的讲解，并为大家演示了如何从0开始创建一个顺序表和链表，并将他们编写成一个完整的顺序表(链表)。在此基础上，作者还为大家贴心的准备了10个链表的练习题，并将他们详细的讲解了一遍，相信这对初入数据结构的同学们来说一定是一个好的练习。在练习题后面我们还为大家附上了力扣和牛客网的链表练习题链接，有需要的小伙伴可以自己点击。在文章的最后，我们为大家分析了链表和顺序表到底有什么区别……
源码分析篇--Java集合操作（6）顺序表的扩容原理
流年梦里风起舞
12-31 570
2.6.4 顺序表的扩容原理之add（）方法的实现原理 add（）方法用于将元素动态添加到ArrayList容器中。将数据保存在list后，我们可以通过该list进行CRUD操作。我们知道，list（列表）的底层是由数组设计的，因此，数组具备了哪些优缺点，list就具备了哪些优缺点。我们知道，链表与数组是两种不同的数据结构，数据结构可以分为线性结构和非线性结构，在线性结构中，存储方式又分为连续存...
【上机实验】01：顺序表扩容
https://blog.csdn.net/m0_74834215
04-17 3074
顺序表扩容 程序=算法+数据结构 数据结构=结构定义+结构操作 程序设计=算法+数据结构+编程范式 1.顺序表操作： 注意：顺序表与数组的不同点在于顺序表支持动态扩容操作 #include<stdio.h> #include<stdlib.h> #include<time.h> typedef struct{ int *data; int size, length; }SqList; //1.顺序表初始化 SqList *init(int n)
Java实现顺序表
xaiobit_hl的博客
05-13 1013
目录 集合框架 ArrayList 1.集合框架 在实现顺序表之前我想先简单介绍一下集合框架，因为先了解这一块的框架，我们才会有目的性的，有方向感的去学习每一个数据结构，自己学了多少让自己心里也有个谱。 1.1.那什么是集合呢？ Java 集合框架 （Java Collection Framework），又被称为容器 （container），是定义在 java.util 包下的一组接口和其实现类，它的主要表现为对单元中的元素进行增删查改操作（CURD）。 类和接口总览 1.2...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

'Dream是普通小孩耶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值