数据结构——数组

最新推荐文章于 2024-08-09 16:47:28 发布
最新推荐文章于 2024-08-09 16:47:28 发布
阅读量495 收藏 2
点赞数 2
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73618358/article/details/137048559
版权

数组定义：

 在计算机科学中，数组是由一组元素（值或变量）组成的数据结构，每个元素有至少一个索引或键来标识。

因为数组内的元素是连续存储的，所以数组中元素的地址，可以通过其索引计算出来。

性能空间占用

java中所有对象的大小都是8字节的整数倍，不足的要用对齐字节补足

随机访问

即根据索引查找元素，时间复杂度是O(1)

动态数组
 private int size; // 逻辑大小
    private int capacity=8; // 容量
    private int[] array=new int[capacity];
插入
//向最后的位置[size]添加元素
 public void addLast(int element){
        array[size]=element;
        size++;
    }
//向[0....size]位置添加元素
    public void add(int index,int element){
        //未考虑数组扩容问题
        if(size>=0&&index<size) {
            //进行一个拷贝
            System.arraycopy(array, index, array, index + 1, size - index);
            array[index] = element;
            size++;
        } else if(index==size){//addLast
            array[index]=element;
            size++;
        }

    }

public void add1(int index,int element){
        if(size >= 0 && index < size){
            System.arraycopy(array,index,array,index+1,size-index);
        }
        array[index]=element;
        size++;
    }
查询和遍历元素

    //查询元素
    public int get(int index){//[0....size]
        return array[index];
    }
    //打印每个元素
    public void foreach(){
        for (int i=0;i<size;i++){
            System.out.println(array[i]);
        }
    }

    //函数式接口
    //遍历方法1，consumer接口 遍历执行的操作，每个元素入参
    public void foreach1(Consumer<Integer> consumer){
       for(int i=0;i<size;i++){
           consumer.accept(array[i]);
       }
    }

    //Iterator 是个接口，要有实现类
    //迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        //java里叫匿名内部类
        return new Iterator<Integer>() {
            int i=0;
            @Override
            public boolean hasNext() {//有没有下一个严肃
                return i<size;
            }

            @Override
            public Integer next() {//返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    public IntStream stream(){
        //IntStream 传的数字不仅有有效数字，还有无效的 eg：1,2,3,4,0,0,0,0
        return IntStream.of(Arrays.copyOfRange(array,0,size));
    }
  public static void main(String[] args) {

        System.out.println("Hello world!");
        DynamicArray dynamicArray = new DynamicArray();
        dynamicArray.addLast(1);
        dynamicArray.addLast(2);
        dynamicArray.addLast(3);
        dynamicArray.addLast(4);


        dynamicArray.add(2,5);
        for(int i=0;i<5;i++){
            System.out.println(dynamicArray.get(i));
        }


        //迭代器遍历
        for(Integer element:dynamicArray){//hasnext()、next()方法
            System.out.println(element);
        }
    }
删除
 public int remove(int index){  //[0...size]
        int removed=array[index];
        if(index<size-1) {
            //java数组中移动元素的方法
            System.arraycopy(array, index + 1, array, index, size - index - 1);
        }
        size--;
        return removed;
    }

对比数据是否一致（断言）

assertEquals(3,removed);

assertIterable(List.of(1,2,4,5),dynamicArray);

容量不够，先扩容
   private void checkAndGrow() {
        //容量检查
        if(size==0){
            array=new int[capacity];
        }
        if(size==capacity){
            //进行扩容，1.5   1.618   2
            capacity+=capacity>>1;
            int [] newArray=new int[capacity];
            System.arraycopy(array,0,newArray,0,size);
            array=newArray;
        }
    }

插入或删除性能

头部位置，时间复杂度是O(n)

中间位置，时间复杂度是O(n)

尾部位置，时间复杂度是O(1)

全部代码

package org.example;

import java.util.Iterator;
import java.util.Arrays;
import java.util.function.Consumer;
import java.util.stream.IntStream;

//动态数组
public class DynamicArray implements Iterable<Integer>{
    private int size; // 逻辑大小
    private int capacity=8; // 容量
   // private int[] array=new int[capacity];
   private int[] array={};


    //向最后的位置[size]添加元素
    public void addLast(int element){
        array[size]=element;
        size++;
    }

    //向[0....size]位置添加元素
    public void add(int index,int element){
        checkAndGrow();


        //未考虑数组扩容问题
        if(size>=0&&index<size) {
            //进行一个拷贝
            System.arraycopy(array, index, array, index + 1, size - index);
            array[index] = element;
            size++;
        } else if(index==size){//addLast
            array[index]=element;
            size++;
        }

    }

    private void checkAndGrow() {
        //容量检查
        if(size==0){
            array=new int[capacity];
        }
        if(size==capacity){
            //进行扩容，1.5   1.618   2
            capacity+=capacity>>1;
            int [] newArray=new int[capacity];
            System.arraycopy(array,0,newArray,0,size);
            array=newArray;
        }
    }

    public void add1(int index,int element){
        if(size >= 0 && index < size){
            System.arraycopy(array,index,array,index+1,size-index);
        }
        array[index]=element;
        size++;
    }

    //查询元素
    public int get(int index){//[0....size]
        return array[index];
    }
    //打印每个元素
    public void foreach(){
        for (int i=0;i<size;i++){
            System.out.println(array[i]);
        }
    }

    //函数式接口
    //遍历方法1，consumer接口 遍历执行的操作，每个元素入参
    public void foreach1(Consumer<Integer> consumer){
       for(int i=0;i<size;i++){
           consumer.accept(array[i]);
       }
    }

    //Iterator 是个接口，要有实现类
    //迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        //java里叫匿名内部类
        return new Iterator<Integer>() {
            int i=0;
            @Override
            public boolean hasNext() {//有没有下一个严肃
                return i<size;
            }

            @Override
            public Integer next() {//返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    public IntStream stream(){
        //IntStream 传的数字不仅有有效数字，还有无效的 eg：1,2,3,4,0,0,0,0
        return IntStream.of(Arrays.copyOfRange(array,0,size));
    }

    public int remove(int index){  //[0...size]
        int removed=array[index];
        if(index<size-1) {
            //java数组中移动元素的方法
            System.arraycopy(array, index + 1, array, index, size - index - 1);
        }
        size--;
        return removed;
    }


}
二维数组

从行开始遍历比从列开始遍历更快。

局部性原理：（空间方面）

  cpu读取内存（速度慢）数据后，会将其放入高速缓存（速度快）中当中，如果后来的计算机再用到此数据，在缓存中能读到的话，就不必读内存了。

  缓存的最小存储单位是缓存行，一般是64bytes，一次读的数据少了不划算，因此最少读64bytes填满一个缓存行，因此读入某一个数据时也会读取其临近的数据，这就是所谓的空间局部性。

LLLLLindream
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构——数组及广义表.cpp
03-08
数据结构——数组及广义表.cpp
C++——数组模拟链表
12-03
C++中的链表是数据结构中非常重要的一部分，而在链表中，我们可以使用数组来模拟链表的结构。今天，我们将讨论如何使用数组来模拟链表，并实现链表的插入和遍历操作。 首先，我们需要了解链表的基本结构。链表是一...
数据结构——数组定义
weixin_43859696的博客
01-24 838
数组 一、数组的定义 数组是有连续的存储空间和数据类型相同的数据结构 二、数组声明 1、int[] arrs 2、int arrs[] //不推荐使用 三、数组赋值 静态赋值： 1、int[] arrs = new int[]{1,2,3}; 2、int[] arrs = {1,2,3}; 动态赋值： 2、int[] arrs = new int[5]; ...
基础数据结构——数组
xian2h的博客
03-16 128
基础数据结构——数组
数据结构——数组与链表
weixin_61015911的博客
04-30 2424
数据结构——数组与链表一、数组理论基础二、链表理论基础1.链表分类1）单链表2）双链表3）循环链表4）块状链表2.链表的存储方式3.链表的定义4.链表的操作1）删除节点2）插入节点3）查找元素4）更新元素5.虚拟头节点的使用6.与数组的对比 一、数组理论基础 数组是存放在连续内存空间上的相同类型数据的集合。可以方便的通过下标索引的方式获取到下标下对应的数据。 不能单独删除、释放数组中的某个元素，只能覆盖。如果要释放，就是全释放（程序运行结束，回收内存栈空间）。 因为数组的在内存空间的地址是连续的，所以我们在
【数据结构——数组】
努力再努力
02-19 143
数据结构数据结构——数组一、复杂度分析二、使用情况三、数组下标四、特点 数据结构——数组 数组是一种线性表数据结构，使用连续的内存空间来存储具有相同类型的数据。 一、复杂度分析 数组根据下标随机访问的时间复杂度为O（1）。 数据的插入与删除效率较低。 排序数组平均情况的时间复杂度为O（n）。 未排序数组则可特殊分析。 二、使用情况 1.数据大小事前已知，且数据操作较少； 2. 表示多维数组时，数组较为明显； 三、数组下标 数组的下标从0开始。从存储模型来看，下标的含义应该是偏移量。0是偏移量为0的存储首地址
数据结构——数组Array
热门推荐
百锦再的博客
12-21 1万+
数组适用于需要快速随机访问元素的场景，但不适用于频繁的插入和删除操作，以及动态改变大小的需求。如果经常需要进行插入和删除操作，可以考虑使用链表等其他数据结构。
数据结构 —— 数组
YS0813的博客
04-05 963
数据结构 —— 数组 数组结构其实就是一排紧密相邻的可数内存，在编程中算是常见的结构，用于存储多个数据。每个数组元素存放一个数据，可通过数组元素的索引访问、赋值以及取出元素的值。 数组的声明通常包含以下属性：1、起始地址：表示数组名所在内存中的起始地址。2、维度：表示几维数组。（如一维数组、二维数组等）3、索引上限和下限：是指元素在数组中内存所存储位置的上标和下标。4、数组元素个数：是指索引上
数据结构——数组的增删改查
Carol__a的博客
01-24 1987
目录 基础数组 二次封装数组（最基础部分） 数组的增删改查 数组的增加 普通的数组已经确定了数组的大小，没办法进行扩容，也不能进行增删改查 基础数组 public class Main { public static void main(String[] args) { //创建数组arr int[] arr = new int[10]; //给每一个元素赋值 for (int i = 0; i < arr.length; i++) { arr[i]=i; } //使用foreach.
数据结构——数组和广义表
weixin_56103871的博客
12-23 133
数据结构——数组和广义表
Java数据结构——数组实现栈
weixin_43233550的博客
05-06 874
Java数据结构——数组实现栈 public class StackAndQueue { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("输入栈的大小："); int maxSize = scanner.nextInt(); ArrayStack stack = new Array
数据结构与算法——数组（剑指offer拓展篇）
01-21
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 解题...
数据结构的学习——数组和链表.zip
06-04
本资料包“数据结构的学习——数组和链表.zip”着重讲解了两种基本的数据结构：数组和链表，它们在编程中扮演着核心角色，特别是在处理大量数据时。 数组是一种线性数据结构，其中的元素存储在内存中的连续位置。...
高阶数据结构——B树
weixin_74310945的博客
08-08 1204
B树：有序数组+平衡多叉树；B+树：有序数组链表+平衡多叉树；B*树：一棵更丰满的，空间利用率更高的B+树。单论树的高度，查找效率来看B树系列确实不错，但是也存在一些缺点。1.空间利用率低，占用的空间大。2.插入和删除数据时，需要进行分裂，涉及到数据的挪动，效率低。3.虽然比起红黑树等，高度更低，但是在内存中都是一个量级的，搜索效率并不比红黑树快多少（在内存中没什么优势）
数据结构之Map和Set（下）
最新发布
我要学编程的博客
08-09 1197
冲突-解决-闭散列、开散列/哈希桶 手动实现哈希表 哈希表和Java类的关系 有关Map和Set的相关练习：只出现一次的数字、随机链表的复制、宝石与石头、前k个高频单词
树和二叉树
2401_83720143的博客
08-08 518
2、如果对一颗有n个结点的完全二叉树（深度为 | log以2为底n的对数 | +1 ）的结点。1、在二叉树的第i层上至多有2的 i-1次方个结点（i>=1），至少有i个结点。1、具有n个结点的完全二叉树的深度为 ： | log以2为底n的对数 | +1。2、深度为k的二叉树至多有2的k次方减1个结点（k>=1），至少有k个结点。2、如果2i>n,则结点i为叶子结点，无左孩子，否则其左孩子是结点 2i。3、如果2i+1>n，则结点 i无右孩子，否则其右孩子是结点 2i+1。根结点：非空树中无前驱结点的结点。
常见8种数据结构
qq_43575301的博客
08-08 2196
应用于需要后进先出访问元素的场景，如函数调用栈、表达式求值等。应用于需要先进先出访问元素的场景，如任务调度、消息队列等。适用于优先队列，堆排序和实现高效的合并K个有序链表问题。应用于需要表示层次结构的场景，比如文件系统、组织结构等。应用于需要表示网络结构的场景，如社交网络、交通网络等。应用于需要快速查找和插入操作的场景，如字典、缓存等。一般应用于需要快速随机访问元素的场景。适用于需要频繁插入和删除元素的场景。
【数据结构】顺序结构实现：特殊完全二叉树（堆）+堆排序
2203_76003626的博客
08-07 1464
堆+堆排序
CQU计算机科学学院：数据结构——数组详解与实现
本份数据结构英文教学课件《11_Array.pdf》涵盖了数据结构中的核心主题——数组（Arrays）。在计算机科学的背景下，数组是一种基本的数据结构，用于存储具有相同类型的数据元素，并通过唯一的索引进行访问。数组被视...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值