数据结构--＞ArrayList与顺序表

已于 2023-07-07 22:37:15 修改
阅读量134 收藏 3
点赞数 4
分类专栏： 数据结构 文章标签： 数据结构 java
于 2023-07-07 21:01:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74812898/article/details/131586012
版权

目录

1. 线性表

1.1 概念

2. 顺序表

2.1 概念

2.2 接口的实现

3. ArrayList简介

3.1 简介

4. ArrayList使用

4.1 ArrayList的构造

4.2 ArrayList常见操作

4.3 ArrayList的遍历

4.4 ArrayList的扩容机制

4.5 ArrayList的优缺点

5. ArrayList的具体使用

5.1 简单的洗牌算法

5.2 杨辉三角

1. 线性表

1.1 概念

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

2. 顺序表

2.1 概念

  • 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成 数据的增删查改。通过方法来操作数组
  • 顺序表在逻辑上是连续的，在物理上也是连续的。

2.2 接口的实现

package demo1;

public class PosOutBoundsException extends RuntimeException {
    public PosOutBoundsException() {
    }

    public PosOutBoundsException(String message) {
        super(message);
    }
}

package demo1;

import java.util.Arrays;

public class SeqList {
    private int[] elem;
    private int usedSize;//记录当前顺序表当中有多少个有效的数据
    private static final int DEFAULT_CAPACITY = 10;

    public SeqList(){
        this.elem = new int[DEFAULT_CAPACITY];
    }

    //打印顺序表
    public void display(){
        for(int i = 0; i < this.usedSize; i++){
            System.out.println(this.elem[i] + " ");
        }
        System.out.println();
    }

    //新增元素
    public void add(int data){
        //首先得判断满的情况
        if(isFull()){
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        this.elem[usedSize] = data;
        usedSize++;
    }

    public boolean isFull(){
        return usedSize == elem.length;
    }

    //判断是否包含某个元素
    public boolean contains(int toFind){
        for(int i = 0; i < this.usedSize; i++){
            if(elem[i] == toFind){//如果数组中存储的时引用数据类型，这里能否继续用等号去比较
                return true;
            }
        }
        return false;
    }

    //查询某个元素对应的位置，下标
    public int indexOf(int toFind){
        for(int i = 0; i < this.usedSize; i++){
            if(elem[i] == toFind){//如果数组中存储的时引用数据类型，这里能否继续用等号去比较
                return i;
            }
        }
        return -1;
    }

    //获取pos位置的元素
    public int get(int pos){//pos一定合法吗
        if(pos < 0 || pos >=usedSize){
            throw new PosOutBoundsException("get 获取数据时 位置不合法");
        }
        return elem[pos];
    }

    //获取顺序表长度
    public int size(){
        return this.usedSize;
    }

    //给pos位置的值设置为value
    public void set(int pos, int value){
        if(!checkPos(pos)){
            throw new PosOutBoundsException("set 数据时，位置不合法");
        }
        this.elem[pos] = value;
    }

    private boolean checkPos(int pos){
        if(pos < 0 || pos >=usedSize){
            return false;
        }
        return true;
    }

    //在pos位置新增元素
    //要连续
    public void add(int pos,int data){

        if(pos < 0 || pos > usedSize){
            throw new PosOutBoundsException("add 元素时，pos位置不合法");
        }
        if(isFull()){
            elem = Arrays.copyOf(elem,2*elem.length);
        }
        //挪数据
        for (int i = usedSize-1; i >= pos;i--){
            this.elem[i+1] = this.elem[i];
        }
        //存数据
        this.elem[pos] = data;
        this.usedSize++;
    }


    private void resize(){
        elem = Arrays.copyOf(elem,2*elem.length);
    }


    //删除第一次出现的关键字key
    public void remove(int toRemove){
        //要删除值的下标
        //index < us-1
        //us--
        if(isEmpty()){
            return;
        }
        int index = indexOf(toRemove);
        if(index == -1){
            return;//没有你要删除的数字
        }
        for (int i = index; i < usedSize-1; i++){
            this.elem[i] = this.elem[i+1];
        }
        usedSize--;
        //elem[us] = null;
    }

    public boolean isEmpty(){
        return usedSize == 0;
    }

    //清空顺序表
    public void clear(){
        /*for (int i = 0; i < usedSize; i++){
            this.elem[i] = null;
        }*/  //如果是引用类型，全部置空，回收，否则占内存（内存泄漏）
        usedSize = 0;
    }
}
package demo1;

public class test2 {
    public static void main(String[] args) {
        SeqList seqList = new SeqList();
        for (int i = 0; i < 10; i++){
            seqList.add(i,i);
        }
        /*seqList.add(1);
        seqList.add(2);
        seqList.add(3);
        seqList.add(4);
        seqList.add(5);
        seqList.add(6);*/
        seqList.display();
    }
}

3. ArrayList简介

3.1 简介

 

  1. ArrayList是以泛型方式实现的，使用时必须要先实例化
  2. 和Vector不同，ArrayList不是线程安全的，在单线程下可以使用，在多线程中可以选择Vector或者 CopyOnWriteArrayList 
  3. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

4. ArrayList使用

4.1 ArrayList的构造

方法解释
ArrayList()无参构造
ArrayList(Collection<?extends E>c)利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity)指定顺序表初始容量

①无参构造

总结：当调用不带参数的构造方法的时候，底层的数组长度为0，但是当我第一次add时，才会为我分配内存，此时第一次分配的内存为10

②利用其他 Collection 构建 ArrayList

③指定顺序表初始容量

4.2 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

②一些简单的例子：

package demo3;

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

public class test1 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("abc");
        arrayList.add("mn");
        arrayList.add("jvof");
        System.out.println(arrayList);
        System.out.println("============");

        List<String> ret1 = arrayList.subList(1,3);
        ret1.set(0,"momo");
        System.out.println(ret1);
        System.out.println("============");

        List<String> list = new ArrayList<>();
        list.add("hello");
        list.addAll(arrayList);
        System.out.println(list);
        System.out.println("===========");

        boolean ret = list.remove("hello");
        System.out.println(ret);
        System.out.println(list);
        System.out.println("============");

        list.clear();
        System.out.println(list);


    }
}

4.3 ArrayList的遍历

①for循环＋下标

package demo2;

import java.util.ArrayList;

public class tets1 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("abc");
        arrayList.add("efg");
        arrayList.add("kjl");
        arrayList.add("mmm");
        for (int i = 0; i < arrayList.size();i++){
            System.out.println(arrayList.get(i)+" ");
        }
        System.out.println();
    }
}

②foreach

package demo2;

import java.util.ArrayList;

public class test2 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("abc");
        arrayList.add("efg");
        arrayList.add("kjl");
        arrayList.add("mmm");
        for (String x: arrayList){
            System.out.println(x+" ");
        }
    }
}

③使用迭代器

package demo2;

import java.util.ArrayList;
import java.util.Iterator;

public class test3 {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("abc");
        arrayList.add("efg");
        arrayList.add("kjl");
        arrayList.add("mmm");

        Iterator<String> it = arrayList.listIterator();
        while(it.hasNext()){
            System.out.println(it.next()+" ");
        }
        System.out.println();
    }
}

4.4 ArrayList的扩容机制

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

看下列代码：

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

由4.1①可知，ArrayList在插入元素的过程中会自动扩容。

总结：

1.检测是否真正需要扩容，如果是调用grow准备扩容

2.预估需要库容的大小：

  •   初步预估按照1.5倍大小扩容
  •   如果用户所需大小超过预估1.5倍大小，则按照用户所需大小扩容
  •   真正扩容之前检测是否能扩容成功，防止太大导致扩容失败

3.使用copyOf进行扩容

4.5 ArrayList的优缺点

一、优点：

①根据指定下标（索引）去查找元素，效率非常高，时间复杂度为O（1）

②更新元素也很快，更新指定下标的元素

二、缺点：

①每次插入数据，都要移动元素，极端情况下，如果插入到0下标，那么移动的元素复杂度O（N)

②每次删除数据的时候，都需要移动元素，极端情况下，删除0下标的元素：O（N)

③当满了之后，进行扩容，1.5倍扩容。如果只放了1个元素，可能会浪费空间

三、总结：

顺序表适用于经常进行查找元素或者更新元素的场景下

5. ArrayList的具体使用

5.1 简单的洗牌算法

（三人轮流揭洗过的牌五张）分析：

1.每个人揭的牌都放到哪里

 2.怎么知道我现在揭牌到哪个list

 3.怎么揭牌

 4.怎么实现3个人每个人轮流揭牌5张

 完整代码如下所示：

package demo1;

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

public class Test {
    //花色
    private  static final String[] SUITS ={"♥","♠","♦","♦"};

    public static List<Card> buyCard(){
        List<Card> cards = new ArrayList<>();

        for (int i = 0; i < SUITS.length; i ++){
            for (int j = 1; j <= 13 ; j++){
                Card card = new Card(SUITS[i],j);
                cards.add(card);
            }
        }
        return cards;
    }

    //洗牌
    public static void shuffle( List<Card> cards){
        Random random = new Random();//生成随机数

        for (int i = cards.size()-1; i > 0; i--){
            int j = random.nextInt(i);
            //交换
            Card tmp = cards.get(i);
            cards.set(i,cards.get(j));//更新i下标的值
            cards.set(j,tmp);///更新j下标的值
        }

    }


    public static void main(String[] args) {
        List<Card> cards = buyCard();
        System.out.println(cards);
        System.out.println("洗牌：");
        shuffle(cards);
        System.out.println(cards);

        //3个人，每个人轮流接牌5张
        //每个人轮流接的牌都放到哪里
        List<Card> hand1 = new ArrayList<>();
        List<Card> hand2 = new ArrayList<>();
        List<Card> hand3 = new ArrayList<>();
        List<List<Card>>  hand = new ArrayList<>();//二维数组
        hand.add(hand1);
        hand.add(hand2);
        hand.add(hand3);

        for (int i = 0; i < 5; i++){
            for (int j = 0; j < 3; j++){
                //接牌的动作
                Card card = cards.remove(0);
                //如何放到指定的人手里
                hand.get(j).add(card);//j下标获取list
            }
        }
        System.out.println("第一个人的牌：");
        System.out.println(hand1);
        System.out.println("第二个人的牌：");
        System.out.println(hand2);
        System.out.println("第三个人的牌：");
        System.out.println(hand3);
        System.out.println("剩下的牌：");
        System.out.println(cards);
    }
}
package demo1;

public class Card {
    private String suit;///花色
    private int rank;//数字

    public Card(String suit, int rank) {
        this.suit = suit;
        this.rank = rank;
    }

    public String getSuit() {
        return suit;
    }

    public void setSuit(String suit) {
        this.suit = suit;
    }

    public int getRank() {
        return rank;
    }

    public void setRank(int rank) {
        this.rank = rank;
    }

    @Override
    public String toString() {
        return suit + " " + rank ;
    }
}

5.2 杨辉三角

链接

分析：

首位的数字：1

中间的数字：[i][j]= [i-1][j-1]+[i-1][j]

import java.util.ArrayList;
import java.util.List;
//杨辉三角
public class test {

    public List<List<Integer>> generate(int numRows){
        List<List<Integer>> ret = new ArrayList<>();
        List<Integer> list =new ArrayList<>();
        list.add(1);

        ret.add(list);
        for (int i = 1; i < numRows; i++){
            List<Integer> curRow =new ArrayList<>();
            curRow.add(1);
            //处理中间的数字
            List<Integer> perRow = ret.get(i-1);//上一行
            for (int j = 1; j < i; j++){
                int val = perRow.get(j)+perRow.get(j-1);
                curRow.add(val);
            }
            //最后一个数字1
            curRow.add(1);
            ret.add(curRow);
        }
        return ret;
    }
小笨猪-
关注
  • 4
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
数据结构-链表 JAVA语言实现
08-24
数据结构-链表 JAVA语言实现,包含单向链表、双向链表、循环链表的遍历、删除和插入 详细介绍：http://blog.csdn.net/z740852294/article/details/77369439
Java数据结构 | ArrayList与顺序表
m0_56361048的博客
10-06 1120
ArrayList与顺序表详解
【数据结构】ArrayList与顺序表
qq_74455045的博客
05-10 659
List接口；线性表；顺序表；ArrayList常用方法及其实现；ArrayList的构造方法、遍历、扩容；CVTE面试题：删除相同字符；洗牌算法；杨辉三角；ArrayList的优缺点
[Java]数据结构---顺序表
Crystal_learner的博客
01-30 610
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。【说明】ArrayList是以泛型方式实现的，使用时必须要先实例化。
Java数据结构-1 ArrayList顺序表实现
Xucc_x的博客
05-25 2678
1. ArrayList子类   ArrayList是JavaCollection接口下List子接口的实现子类。它是一个长度可变的数组，底层是以数组为基础的顺序表实现的。所以说研究Java顺序表数据结构必须得了解一下ArrayList类。 // ArrayList定义 public class ArrayList&amp;amp;lt;E&amp;amp;gt; extends AbstractList&amp;amp;lt;E&amp;amp;gt...
数据结构 Java数据结构 --- List ArrayList
wwzzzzzzzzzzzzz的博客
12-03 1547
文章目录List1. 预备知识-泛型(Generic)1.1 泛型的引入1.2 泛型类的简单演示1.3 泛型的意义1.4 泛型是怎么编译的?1.5 泛型总结2 . 包装类2.1 基本数据类型和包装类直接的对应关系2.2 包装类的使用，装箱(boxing)和拆箱(unboxing)3 . ArrayList简介4 . ArrayList使用4.1 ArrayList的构造4.2 ArrayList的遍历4.2.1 迭代器 Iterator ListIterator4.3 ArrayList常见操作
顺序表的链式存储封装ArrayList
03-08
学习数据结构，用C++封装的顺序表，用得链式存储结构
【蓝桥杯】必备的java数据结构和常用方法
01-20
顺序表的实现静态数组动态数组2.链表的实现二.栈三.队列四.串StringString StringBuffer 和 StringBuilder五.树和二叉树六.哈希表七. 图邻接矩阵邻接表 一.线性表 1.顺序表的实现 静态数组 java只有在为数组分配变量...
数据结构实验2 线性表.doc
06-20
（2） 应用顺序表的基本算法实现集合A=AUB算法，应用顺序表的基本算法实现两有序顺序表的归并算法； （3） 掌握单链表的遍历、插入和删除等操作算法，实现多项式相加。 二、 实验内容： 1、设有线性表 LA＝（3,5,8,...
ArrayList和Linkedlist1
08-08
1.List是接口类，ArrayList和LinkedList是List的实现类 2.ArrayList是动态数组（顺序表）的数据结构 3.LinkedList
Java—选择排序
qq_56725871的博客
05-22 254
它的基本思想是从待排序的数据中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），然后再从剩余未排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾（或开头），以此类推，直到全部元素排序完成。选择排序的时间复杂度为O(n^2)，其中n为待排序数组的长度。尽管选择排序的时间复杂度较高，但它简单易懂，适用于小规模数据的排序。对于大规模数据，更高效的排序算法如快速排序和归并排序更为常用。以上代码通过遍历整个数组，找到剩余未排序部分的最小值，并将其与当前位置的元素交换，重复这个过程直到数组排序完成。
刷题篇--数据结构--链表
hyldzbg的博客
05-18 442
如果我们有一个链表是1-->2-->3-->4-->5这样的，那我们反转后就是5-->4-->3-->2-->1这样的，那么要如果对链表操作呢？我们可以发现在反转后的链表里1-->2,变成2-->1那么我们就顺着这个思路，直接将下一个节点插到头节点前不就好了！！看起来好像不是很难，但是实现起来却很简单😉👌，嘿嘿！(^0^)我们可以再思考一下，将一个节点插到头节点前不就是头插嘛对不对，所以我们可以直接利用头插的方法来解决问题。
数据结构：二叉树---堆
Auroral_0218的博客
05-18 656
二叉树是一种特殊的树结构，其中每个节点最多有两个子节点。堆是一个完全二叉树：除了最后一层外，其他层节点个数都是满的，最后一层的节点都集中在左侧。堆中每个节点的值大于等于（或小于等于）其子节点的值，这个性质被称为堆序性。堆是一种特殊的数据结构，用于存储和管理一组元素。它的主要作用包括：1. 优先级队列：堆可以将元素按照一定的优先级进行排序，使得可以快速访问和操作优先级最高的元素。这在诸如调度算法、事件处理等场景中非常有用。2. 堆排序：堆排序是一种高效的排序算法，它利用堆的性质将元素快速排序。
二叉树——基础知识详解
2302_81016149的博客
05-22 1122
对于二叉树基础的理论知识，我们就学习到这里，虽然这些知识相对后面来说简单一点，但别忘记复习。有了这些预备知识才能够更好的理解后面知识。另外对于递归理解还不够的读者一定要去尽可能的去理解，对于二叉树的学习非常重要。今天的学习就结束了，有问题可在评论区交流，也可私信。我们下篇见！完！
数据结构——栈
2302_80339723的博客
05-15 338
1.我们可以定义一个结构体（ struct stack），其中有数组（SLDataType *a），栈顶元素的下标（top）和栈的空间（capacity）。通常为0.我们会将栈为空时状态定义为以下，但是如果将没有元素时top为0，这是top指向的就不是栈顶元素，而是栈顶元素的下一个元素。我们可以实现一个静态栈（数组的长度是一定），但是这种结构并不实用，我们接下来实现的是动态栈。如果不是左括号，就要判断栈是不是为空，若为空，直接返回false，不为空，再取栈顶元素与之比较。总体来说，实现一个栈还是很容易的。
android高斯模糊填充imageview背景
cf8833的博客
05-21 356
说明：最近碰到一个需求，安卓app显示在线的url图片，然后imageview没占满的部分，使用该图片的模糊背景填充。
SpringBoot接入Knife4j接口文档
博主是个二次元死肥宅~
05-18 780
Knife4j是Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui。
分布式锁2-Zookeeper分布式锁实战
qq_43676797的博客
05-19 429
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
java学习和项目总结
最新发布
2301_79390585的博客
05-24 268
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
ArrayList是顺序表还是广义表
06-09
顺序表是一种常见的数据结构，它将数据元素存储在连续的存储空间中，并通过线性索引来访问元素。因此，顺序表支持随机访问，可以在O(1)的时间复杂度内访问任意位置的元素。 相对于顺序表，广义表则是一种更加复杂的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值