数据结构-数组

已于 2024-02-23 16:19:51 修改
阅读量956 收藏 17
点赞数 27
文章标签： 数据结构 java
于 2024-02-22 18:19:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76460223/article/details/136240366
版权
本文详细介绍了Java中的数组基础概念，包括数组的创建、索引使用、常见错误以及动态数组的操作方法，如添加、删除和查找，同时分析了数组的各种操作的时间复杂度。
摘要由CSDN通过智能技术生成

一,数组基础及注意事项

1,用来储存一组相同的类型的数据.
2,在内存中,分配连续的空姐,数组创建时要指定容量(大小).
3,创建格式: 数据类型 []数组名  int[] arr = new int[10] int[] arr2 = {1,2,3,4}.
4,索引--访问数组时通过索引进行操作.
(注意:一定要理解索引的含义,在数据结构的学习中基本每次都用,索引简单的可以理解为,待插入元素,即,还没有赋值的第一个元素.)
5.索引从0开始,最大为数组名.length-1;
6,常见的错误: NullPointException ArrayIndexOutOfBoundsException 即我们常说的空指针h=和越界.
7,常见的数组:字符串,对象数组,哈希表

二,演示数组的使用,及数组的方法使用

使用数组时，最重要的就是数组的 索引 ，通过索引可以对数组进行改和查操作。
接下来用图 来演示
1,向数组中添加元素
2,向指定位置添加元素

3,向数组头添加元素
4,获取指定位置的元素和修改指定位置的元素
5,包含、搜索和删除元素

首先:对int类型的数组进行操作

接下来让我们手撕代码.:

import java.util.Arrays;
import java.util.Random;

// 封装属于自己的数组
public class MyArray {
    private int[] data; // 底层数据结构
    private int size;// 用来保存实际存放元素的个数

    public MyArray() {
        this(100);
    }

    public MyArray(int capacity) {
        this.data = new int[capacity];
        this.size = 0;
    }

    // 判断数组是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }

    // 获取数组实际存放元素的个数
    public int getSize() {
        return this.size;
    }

    // 对数组进行操作
    /*
    * 1、增加的方法
       发现：this.size指向待插入元素的位置，因此，可以在this.size位置增加元素
       在头部增加： 1》 将数组中的元素后移，2》 将val添加到索引为0的位置
       * 在任意位置添加
     */

    /**
     * 在尾部添加
     *
     * @param val val
     */
    public void addTail(int val) {
        add(this.size, val);
    }

    /**
     * 在头部添加
     *
     * @param val val
     */
    public void addHead(int val) {
        add(0, val);
    }

    /**
     * 在任意位置添加
     *
     * @param position 插入的位置
     * @param val      插入的值
     */
    public void add(int position, int val) {
        if (position < 0 || position > this.size) {
            throw new IllegalArgumentException("position is invalid");
        }
        for (int i = this.size - 1; i >= position; i--) {
            this.data[i + 1] = this.data[i];
        }
        this.data[position] = val;
        this.size += 1;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < this.size; i++) {
            sb.append(this.data[i] + ",");
        }
        String result = sb.toString();
        return result.substring(0, result.length() - 1);
    }

    //获取指定位置的元素
    public int getElementByIndex(int index) {
        if (index < 0 || index >= this.size) {
            throw new IllegalArgumentException("index is invalid");
        }
        return this.data[index];
    }

    // 修改指定位置的元素
    public void setElementByIndex(int index, int val) {
        if (index < 0 || index >= this.size) {
            throw new IllegalArgumentException("index is invalid");
        }
        this.data[index] = val;
    }

    // cotains 用来判断数组中是否包含指定的元素
    public boolean contains(int searchVal) {
        for (int i = 0; i < this.size; i++) {
            if (this.data[i] == searchVal) {
                return true;
            }
        }
        return false;
    }

    // 查找指定元素在数组中的索引
    public int findIndex(int searchVal) {
        for (int i = 0; i < this.size; i++) {
            if (this.data[i] == searchVal) {
                return i;
            }
        }
        return -1;
    }

    // 删除数组中最后一个元素
    public int removeFromTail() {
        if (isEmpty()) {
            throw new IllegalArgumentException("this array is null!");
        }
        return this.data[--this.size];
    }

    // 删除数组中的第一个元素
    public int removeFromHead() {
        if (isEmpty()) {
            throw new IllegalArgumentException("this array is null!");
        }
        // 1、先保存数组中的第一个元素
        int result = this.data[0];

        // 2、将数组从索引为1的位置进行前移
        for (int i = 1; i < this.size; i++) {
            this.data[i - 1] = this.data[i];
        }
        this.size--;
        return result;
    }

    // 删除指定位置的元素
    public int removeByIndex(int index) {
        if (index < 0 || index >= this.size) {
            throw new IllegalArgumentException("index is invalid!");
        }
        int result = this.data[index];
        // 从索引为index位置的元素进行前移
        for (int i = index; i < this.size - 1; i++) {
            this.data[i] = this.data[i + 1];
        }
        this.size--;
        return result;
    }

    // 删除指定的元素
    public void remove(int val) {
        for (int i = 0; i < this.size; ) {
            if (this.data[i] == val) {
                // 删除元素---将后面的元素前移，然后更新size
                for (int j = i; j < this.size - 1; j++) {
                    this.data[j] = this.data[j + 1];
                }
                this.size -= 1;
            } else {
                i++;
            }
        }
    }

}

我们要进行任意数据类型的数组,这时就要使用泛型来进行操作.

接下来让我们手撕代码.在上述我们自己写的int类型数组进行修改,添加泛型.

import java.util.Random;

// 封装属于自己的数组,使用泛型
public class MyArray2<T> {
    private T[] data; // 底层数据结构
    private int size;// 用来保存实际存放元素的个数

    private int capacity; // 表示容积

    public MyArray2() {
        this(100);
    }

    public MyArray2(int capacity) {
        this.capacity = capacity;
        this.data = (T[]) new Object[this.capacity];
        this.size = 0;
    }

    // 获取容积的方法
    public int getCapacity() {
        return this.capacity;
    }

    // 判断数组是否为空
    public boolean isEmpty() {
        return this.size == 0;
    }

    // 获取数组实际存放元素的个数
    public int getSize() {
        return this.size;
    }

    // 对数组进行操作
    /*
    * 1、增加的方法
       发现：this.size指向待插入元素的位置，因此，可以在this.size位置增加元素
       在头部增加： 1》 将数组中的元素后移，2》 将val添加到索引为0的位置
       * 在任意位置添加
     */

    /**
     * 在尾部添加
     *
     * @param val val
     */
    public void addTail(T val) {
        add(this.size, val);
    }

    /**
     * 在头部添加
     *
     * @param val val
     */
    public void addHead(T val) {
        add(0, val);
    }

    /**
     * 在任意位置添加
     *
     * @param position 插入的位置
     * @param val      插入的值
     */
    public void add(int position, T val) {
        if (position < 0 || position > this.size) {
            throw new IllegalArgumentException("position is invalid");
        }
        // 在增加之前，判断数组是否已满，如果已满，要进行扩容
        if (this.size == this.capacity) {
            // 扩容操作
            resize(this.capacity*2);
        }
        for (int i = this.size - 1; i >= position; i--) {
            this.data[i + 1] = this.data[i];
        }
        this.data[position] = val;
        this.size += 1;
    }

    // 改变容积的方法
    private void resize(int newCapacity) {
        System.out.println("--------resize--------");
        // 2、 创建一个新数组
        T[] newArr = (T[]) new Object[newCapacity];

        // 3、将原来数组的内容转移到新数组
        for (int i = 0; i < this.size; i++) {
            newArr[i] = this.data[i];
        }
        // 4、将newArr赋值给 this.data
        this.data = newArr;
        // 5、将newCapacity 赋值给this.capacity
        this.capacity = newCapacity;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < this.size; i++) {
            sb.append(this.data[i] + ",");
        }
        String result = sb.toString();
        return result.substring(0, result.length() - 1);
    }

    //获取指定位置的元素
    public T getElementByIndex(int index) {
        if (index < 0 || index >= this.size) {
            throw new IllegalArgumentException("index is invalid");
        }
        return this.data[index];
    }

    // 修改指定位置的元素
    public void setElementByIndex(int index, T val) {
        if (index < 0 || index >= this.size) {
            throw new IllegalArgumentException("index is invalid");
        }
        this.data[index] = val;
    }

    // cotains 用来判断数组中是否包含指定的元素
    public boolean contains(T searchVal) {
        for (int i = 0; i < this.size; i++) {
            if (this.data[i].equals(searchVal)) {
                return true;
            }
        }
        return false;
    }

    // 查找指定元素在数组中的索引
    public int findIndex(T searchVal) {
        for (int i = 0; i < this.size; i++) {
            if (this.data[i].equals(searchVal)) {
                return i;
            }
        }
        return -1;
    }

    // 删除数组中最后一个元素
    public T removeFromTail() {
        return removeByIndex(this.size-1);
    }

    // 删除数组中的第一个元素
    public T removeFromHead() {
        return removeByIndex(0);
    }

    // 删除指定位置的元素
    public T removeByIndex(int index) {
        if (index < 0 || index >= this.size) {
            throw new IllegalArgumentException("index is invalid!");
        }
        T result = this.data[index];
        // 从索引为index位置的元素进行前移
        for (int i = index; i < this.size - 1; i++) {
            this.data[i] = this.data[i + 1];
        }
        this.size--;
        if(this.size <= this.capacity/2 && this.capacity/2>1){
            resize(this.capacity/2);
        }
        return result;
    }

    // 删除指定的元素
    public void remove(int val) {
        for (int i = 0; i < this.size; ) {
            if (this.data[i].equals(val)) {
                // 删除元素---将后面的元素前移，然后更新size
                for (int j = i; j < this.size - 1; j++) {
                    this.data[j] = this.data[j + 1];
                }
                this.size -= 1;
            } else {
                i++;
            }
        }
        // 删除之后，进行判断是否要进行缩容,如果需要缩容，缩到原容积的1/2
        if(this.size <= this.capacity/2 && this.capacity/2>1){
            resize(this.capacity/2);
        }
    }
}

代码较长希望有心人可以看完.

三,数组的复杂度分析.

我们对数组的逻辑有了简单的了解,就对数组的复杂度进行分析,后面可以通过比较复杂度,来选择合适的数据结构来储存数据.

1,分析动态数组的时间复杂度

(1),添加操作

 1,addLast(e) O(n)

2,addFirst(e)  O(1)  渐进时间复杂度

3,add(index,e) O(n^2) 描述n趋近于无穷的情况

(2),添加操作

(3),删除操作

(4),修改操作

(5),查找操作

(6) 综合

扫树叶
关注
数据结构-数组Array(二维)
weixin_43486332的博客
07-19 2683
二维数组是特殊的一维数组，这个特殊的一维数组(二维数组)当中的每一个元素是一个一维数组。 二维数组里面存的是一维数组，二维数组里面的元素个数是一维数组的元素个数。 二维数组内存图： 二维数组地址计算公式： U：每个元素占的字节数 n：元素总个数 //一维数组 int[] a = {10,20,30}; System.out.println("一维数组："+a.length);3 //二维数组 int[][] b = { {1,2,3}, {4,5},..
24考研数据结构-数组和特殊矩阵
VengaZ的学习博客
07-29 1403
数组和特殊矩阵
数据结构-数组操作
Mreden的博客
06-12 1234
原文链接:https://www.goroutine.me/datastructure/2019/06/03/data-structure-array-linked-hash.html 数据结构中的数组基本操作,我这里是也是为了学习记录我自己的书写的代码过程.其中包含取数组的新建,新增元素,删除元素,取指定索引值,向元素尾部追加元素 等等! 1、 场景 1.1、 中文描述 数据结构中的数组基本操作...
【C++专项练习】数据结构-数组-求二维数组存储地址
m0_67003637的博客
11-02 1335
已知 10*12 的二维数组 A ，以行序为主序进行存储，每个元素占 1 个存储单元，已知 A[1][1] 的存储地址为 420 ，则 A[5][5] 的存储地址为 （ ）
python常用数据结构---数组
qq_43061415的博客
03-09 1470
Python中常用的数据结构 常用的数据结构有数组、链表(一对一)、栈和队列、哈希表、树(一对多)、图(多对多)等结构。 在本目录下我们将讲解，通过python语言实现常用的数据结构。 1.数组 在python语言中，并没有直接使用数组这个概念，而是使用列表（list）和元组（tuple）这两种集合，它们的本质都是对数组的封装。其中，列表是一个动态可扩展的数组，支持任意的添加、删除、修改元素；而元组是一个不可变集合，一旦创建就不支持修改，即不支持添加、删除、修改操作，只支持查看。 下面我们提到的数组概念，对
数据结构--数组和链表
赤兔胭脂小吕布的博客
12-20 644
数据结构主要可以分为两大模块： 线性结构 非线性结构 本文主要开始讲线性结构。 什么是线性结构 线性结构，顾名思义，就是这些数据所有节点都能被一根线(指针)联系起来的一种结构。 线性结构的存储方式： 连续存储：【数组】 离散存储：【链表】 线性结构的常见应用方式： 栈 队列 专题 :【递归】 数组和链表 本小节学习数组和链表，从底层去了解和实现数组与链表，并分析两者对应的优缺点 数组...
数据结构——数组
热门推荐
qq_38361726的博客
06-03 1万+
一、数组的概念 　　定义：数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 　　从概念中可以知道一下几点： 数组是线性表。　 　　　所谓的线性表就是数据排成一排，想一条线一样的结构。每个线性表上的数据最多只有前和后两个方向。当然除了数组，链表、队列、栈等也是线性表结构 　　　　　　 连续的内存空间和形同类型的数据。 　　正因为有了上述两个特点，数组才能够有一个堪称“杀手锏”的特性：随机访问 数组实现下标随机访问 　　下面通过一个实际的例子来说明：.
八大数据结构-数组 栈 队列 链表 树 散列表 堆 图
艾小逗
12-31 2034
八大数据结构 —— 数组 栈 队列 链表 树 散列表 堆 图 1. 数组 优点：按照索引查询速度快、遍历数组方便 缺点： 数组大小固定后无法扩容 数组只能存储一种类型的数据 添加删除慢（需要移动其它元素） 使用场景：频繁查询，对存储空间要求不大；增加删除少的情况 一维数组：a[0] a[1] a[2] a[3] 2. 栈 栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底...
数据结构与算法---数组---移除元素
m0_50046535的博客
04-06 775
参考自《代码随想录》 示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。 你不需要考虑数组中超出新长度后面的元素。 ！数组中的元素内存地址连续，不能单独删除数组中的某个元素，只能覆盖。 解法1：暴力解法 class Solution { public: int removeElement(vector<int>& nums, int val) { int size
数据结构-数组&链表&队列&堆栈代码示例程序
09-10
数据结构-数组&链表&队列&堆栈代码示例，附有详细的注释说明，简单移动，适合初学者参考学习。
数据结构-数组与广义表.ppt
07-11
本章主要讨论了两种特定的数据结构：数组和广义表。这两种结构都是线性表的扩展，允许更复杂的数据组织。 数组是一种基本的数据结构，它由n（n>1）个相同数据类型的元素组成，这些元素在内存中占据连续的地址空间。...
数据结构--数组、单链表和双链表介绍以及双向链表 数组和链表.pdf
04-18
数据结构--数组、单链表和双链表介绍以及双向链表 数据结构是计算机科学中的一种基本概念，指的是数据的组织和存储方式。数组、链表是两种常见的数据结构，下面将对它们进行介绍。 一、数组 数组是数据结构中的一...
王道408考研数据结构-线性表-第二章
qq_55882840的博客
09-17 1254
2.1 线性表的定义2.1.1 线性表的定义线性表是具有相同数据类型的n(n≥0)个数据元素的有限序列，其中n为表长，当n=0 时线性表是一个空表。若用L命名线性表，则其一般表示为式中，a1是唯一的“第一个”数据元素，又称表头元素；an是唯一的“最后一个”数据元素，又 称表尾元素。除第一个元素外，每个元素有且仅有一个直接前驱。除最后一个元素外，每个元素有且仅有一个直接后继(“直接前驱”和“前驱”、“直接后继”和“后继”通常被视为同义词)。
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 611
数据结构之字典和哈希表
【用Java学习数据结构系列】对象的比较（Priority Queue实现的前提）
最新发布
2302_81249757的博客
09-20 412
上一篇文章已经给大家大致了解了一下Priority Queue以及它的底层实现---堆，但是其实大家可以发现我们上一篇文章的对象是 int 类型，所以我们进行向上调整和向下调整时我可以使用 “<” “ >” “ ==” 进行比较他们的大小进行比较调整，但是如果我们的Priority Queue 里储存的是一个对象呢？那么这时就涉及到对象的比较了。那么对象如何进行比较就往下看看这篇文章吧。
数据结构(7.3_3)——平衡二叉树的删除
m0_65240792的博客
09-17 477
删除结点后，要保持二叉排序树的特性不变(左<中<右)若删除结点导致不平衡，则需要调整平衡1、寻找最小不平衡子树2、没找到最小不平衡子树，结束查询1、删除结点552、寻找最小不平衡子树3、找最小不平衡树下，“个头”最高的儿子、孙子 4、根据孙子的位置，调整平衡(LL/RR/LR/RL) 5、检查不平衡性是否向上传导 1、删除结点2、寻找最小不平衡子树3、找最小不平衡树下，“个头”最高的儿子、孙子 4、根据孙子的位置，调整平衡(LL/RR/LR/RL) 5、检查不平衡性是否向上传导 1、删除结点2、寻找最
数据结构day2
m0_74933801的博客
09-17 604
D选项正确地使用了点操作符（）来访问结构体stud中的 name 成员。由于 name 是一个字符数组，它可以被printf函数的 %s格式说明符直接用作字符串输出，这正是题目所要求的。①输入学生信息②输出学生信息③计算学生的成绩总分、平均分④按照学生的分数进行排序⑤输出排序后的数组#define Stu_num 5 // 定义学生数量为5//定义学生结构体int id;//学号//姓名//分数}Stu;//输入函数//输出函数//排序函数// 计算总分// 计算平均分。
数据结构-数组深度解析
"数据结构不挂科-4-数组 .pdf" 本文主要讲解了数据结构中的核心概念——数组，包括数组的类型定义、顺序表示和实现，以及稀疏矩阵的压缩存储方法。数组作为一种基础且重要的数据结构，是程序设计中不可或缺的部分。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值