数据结构（数组）

已于 2023-04-10 00:07:30 修改
阅读量1.3k 收藏 5
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构 java 算法
于 2022-10-28 00:20:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56846554/article/details/127563556
版权

数组：

一、数组基础

  1、概念：用来存储一组相同数据类型的数据；

  2、在内存中分配连续的空间，数组创建时要指定容量（大小）；

  3、初始化：

         数据类型[] 数组名  = new int[6];

         数据类型[] 数组名  = {1,2,3,4,5,6};

  4、索引--访问数组时通过索引进行操作

  5、索引从0开始，最大为array.length-1

  6、常见的数组：字符串、对象数组、哈希表

  7、空指针：nullPoint  NullPointException

  8、数组越界:outofindex   ArrayIndexOutOfBoundsException

二、使用数组时，最重要的就是数组的索引，通过索引可以对数组进行改和查操作。

    索引：可以有语义，也可以没有语义（理解），

          数组最好运用于索引有语义的情况；

          数组最大的优点：快速查询。

四、产生的问题：

五、基于java中的数组，进行二次封装，创建可变数组：

1、创建数组：
public class MyselfArray {

    //数据容器
    private int[] data;
    //实际保存数据个数  size表示数组中有效元素的个数
    private int size;

    //指定数组容积
    MyselfArray(){
        this(20);
    }

    //定义数组容积
    MyselfArray(int capacity){
        this.size = 0;
        data = new int[capacity];
    }

    //数据容器
    public int[] getData() {
        return data;
    }

    public void setData(int[] data) {
        this.data = data;
    }

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

    public void setSize(int size) {
        this.size = size;
    }

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

2、在数组指定位置添加元素

    

public void add(int index,int ele){

        //判断数组是否已满
        if(this.size == data.length) {
            throw new IllegalArgumentException("this array is full");
        }

       //判断索引是否有效
        if(index < 0 || index > size){
            throw new IllegalArgumentException("index is error");
        }
        for (int i = size-1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = ele;
        this.size++;
    }

3、在数组尾部添加元素

    //调用“在指定位置添加元素”方法
    public void addTail(int ele){
        add(this.size,ele);
    }

    //直接添加
    public void addTail(int ele){
        if(this.size >= data.length){
            throw new IllegalArgumentException("index our of arrayRange");
        }
        data[size] = ele;
        this.size += 1;
    }

4、在数组头部添加元素

    //调用“在指定位置添加元素”方法
    public void addHead(int ele){
        add(0,ele);
    }

5、获取指定位置元素

    public int getEleByIndex(int index) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index is error");
        }
        return data[index];
    }

6、修改指定位置的元素

    public void updateNuIndex(int index,int ele) {
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("index is error");
        }
        data[index] = ele;
    }

7、是否包含指定元素内容 返回索引

    public int isContains(int ele) {
        for (int i = 0; i < size; i++) {
            if(this.data[i] == ele){
                return i;
            }
        }
        return -1;
    }

8、删除指定位置的元素

   

    public int remove(int index){
        //判断索引的有效性
        if(index < 0 || index >= index){
            throw new IllegalArgumentException("index is invalid");
        }
        //前移操作
        int result = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        this.size--;
        data[size] = 0;
        return result;
    }

9、删除指定元素

    public int removeEle(int ele){
        //判断元素是否存在
        int index = isContains(ele);
        if(index != -1) {
            remove(index);
        }
        return index;
    }

    //删除头部元素
    public int removeHead(){
        return remove(0);
    }

    //删除尾部元素
    public int removeTail(){
        return remove(this.size - 1);
    }

10、方法重写
  

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

11、动态数组  修改数组容积

    public void resize(int newCapacity){
            T[] newData = (T[]) new Object[newCapacity];
            for (int i = 0; i < this.size; i++) {
                newData[i] = data[i];
            }
            this.data = newData;
        }

        //进行缩容操作
        if(this.size == data.length / 2 && data.length / 2 > 0) {
            resize(data.length / 2);
        }

        //如果数组已满，进行扩容操作
        if(this.size == data.length) {
            resize(2 * data.length);
        }

12、使用泛型  （任意类型的数组）

      不能是基本数据类型，只能是类对象

      基本数据类型：8种

           byte  char  boolean  int  short  float  double  long

      每种基本数据类型都有一个对应的包装类。

//使用泛型
public class MyselfArrays<T> {
    //数据容器
    private T[] data;
    //实际保存数据个数  size表示数组中有效元素的个数
    private int size;

    MyselfArrays(){
        this(20);
    }

    //capacity  数组容积
    MyselfArrays(int capacity){
        this.size = 0;
        data = (T[]) new Object[capacity];
    }

    //数据容器
    public T[] getData() {
        return data;
    }

    public void setData(T[] data) {
        this.data = data;
    }

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

    public void setSize(int size) {
        this.size = size;
    }

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

    //向数组尾部添加元素
    public void addTail(T ele){
        add(this.size,ele);
/*        if(this.size >= data.length){
            throw new IllegalArgumentException("index our of arrayRange");
        }
        data[size] = ele;
        this.size += 1;*/
    }

    //向指定位置添加元素
    public void add(int index,T ele){
        //判断数组是否已满
        //如果数组已满，进行扩容操作
        if(this.size == data.length) {
            resize(2 * data.length);
        }
        //判断索引是否有效
        if(index < 0 || index > size){
            throw new IllegalArgumentException("index is error");
        }
        for (int i = size-1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = ele;
        this.size++;
    }

    //在数组头部添加
    public void addHead(T ele){
        add(0,ele);
    }

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

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

    //是否包含指定元素内容 返回索引
    public int isContains(T ele) {
        for (int i = 0; i < size; i++) {
            if(this.data[i].equals(ele)){
                return i;
            }
        }
        return -1;
    }


    //删除指定位置的元素
    public T remove(int index){
        //判断索引的有效性
        if(index < 0 || index >= index){
            throw new IllegalArgumentException("index is invalid");
        }
        //前移操作
        T result = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        this.size--;
        data[size] = null;

        //进行缩容操作
        if(this.size == data.length / 2 && data.length / 2 > 0) {
            resize(data.length / 2);
        }
        return result;
    }

    //删除指定元素
    public int removeEle(T ele){
        //判断元素是否存在
        int index = isContains(ele);
        if(index != -1) {
            remove(index);
        }
        return index;
    }

    //删除头部元素
    public T removeHead(){
        return remove(0);
    }

    //删除尾部元素
    public T removeTail(){
        return remove(this.size - 1);
    }


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


    //动态数组 修改数组容积
    public void resize(int newCapacity){
            T[] newData = (T[]) new Object[newCapacity];
            for (int i = 0; i < this.size; i++) {
                newData[i] = data[i];
            }
            this.data = newData;
    }
}

叫我剑锋
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——数组
qq_38361726的博客
06-03 1万+
一、数组的概念 　　定义：数组（Array）是一种线性表数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 　　从概念中可以知道一下几点： 数组是线性表。　 　　　所谓的线性表就是数据排成一排，想一条线一样的结构。每个线性表上的数据最多只有前和后两个方向。当然除了数组，链表、队列、栈等也是线性表结构 　　　　　　 连续的内存空间和形同类型的数据。 　　正因为有了上述两个特点，数组才能够有一个堪称“杀手锏”的特性：随机访问 数组实现下标随机访问 　　下面通过一个实际的例子来说明：.
结构数组（2019.10.24）
weixin_45648485的博客
10-24 1815
结构数组一、结构数组的创建==例3-26==二、结构数组与单元数组的转换==例3-27====例3-28==三、单元数组的数据处理==例3-29== 一、结构数组的创建 结构数组是对某个对象，不同属性的数据，用一组数据来表示，称为结构数组。MATLAB有关结构数组的函数如下表： 结构数组的创建，可以采取直接赋值或用函数struct来创建。 例3-26 下表是几个学生的档案。数组名为student...
【基础(包含GPT)】数据结构（数组）
最新发布
Hwrxia的博客
06-17 924
（选自菜鸟教程）数据结构（英语：data structure）是计算机中存储、组织数据的方式。数据结构是一种具有一定逻辑关系，在计算机中应用某种存储结构，并且封装了相应操作的数据元素集合。它包含三方面的内容，逻辑关系、存储关系及操作。数据结构简单来说就算和数据的方法。能够更高效地数据。常见的数据结构有。
02. 数据结构之数组
wlyang666的博客
05-22 1384
数组（Array）是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。
Matlab-结构数组
qq_41955225的博客
04-18 9352
1 认识结构数组 结构也是一种数据类型，它的每一个元素都有一个名字。称结构中的元素为域。 类似与C语言中的结构体。 2 创建 两种方法： （1）用赋值语句创建 （2）用函数 struct 函数进行创建 2.1 赋值语句创建 student.name="Li Ming"; student.addr="123 Street"; student.city='ShangHai'; student.zip="123456"; student.age=23; 结果： >> stude
数据结构之——数组
IT荻的博客
01-31 3887
数组是线性表，就是数据排成像一条直线一样的结构，除了数组，链表，队列，栈都是线性结构 而非线性表就是二叉树，堆，图等，数据之间不是简单的先后关系。 数组有连续的内存空间和相同类型的数据。正式有了这两个限制，才有了一个堪称杀手锏的特性：“随机访问”，但是删除，插入一个数据，为了保证连续性，就需要做大量的数据搬移工作。 数组和链表的区别？ 我们时常会回答：链表适合插入，删除，时间复杂度为O(1);数组...
数据结构 数组
03-31
数据结构 数组源代码 程序 数组的使用
数据结构数组.ppt
03-18
数据结构的数组相关知识，让你掌握数组的知识，会数据结构的数组，可以完成数据结构的数组大题。让你对数据结构的数组有基础的了解。
数据结构数组
04-08
所谓数组，是有序的元素序列。若将有限个类型相同的变量的集合命名，那么这个名称为数组名。组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。
数据结构 数组顺序存储详细介绍
01-01
数据结构 数组顺序存储  最近学习数据结构，看到数组顺序存储，很是头昏，看不懂，很多东西，这里在网上找了比较详细的资料，大家好好看注释内容： #include #define MAX_ARRAY_DIM 8 //假设数组维数的最大值为8 ...
图解数据结构(01) -- 数组
姜皓的博客
12-26 1541
数组 1、什么是数组 数组对应的英文是 array，是有限个相同类型的变量所组成的有序集合，数组中 的每一个变量被称为元素。数组是最为简单、最为常用的数据结构；以整型数组为例，数组的存储形式如下图所示： 数组中的每一个元素有着自己的下标，只不过这个下标从0开始，一直到数组长度-1；数组的另一个特点，是在内存中顺序存储，因此可以很好地实现逻辑上的顺序表。 数组在内存中的顺序存储：内存是由一个个连续...
数据结构-数组
dimtem的博客
02-17 184
数据结构之数组
数据结构 - 数组
尚未佩妥剑 转眼便江湖
05-12 2120
数组与线性表的差异我们以前应该学习过数组，数组与线性表的区别与联系呢？ 它们的相同之处: （1）它们的相同之处，它们都是若干个相同数据类型的数据元素a0,a1,a2,…，an-1构成的有限序列 它们的不同之处： （1）数组要求其元素占用一块地址连续的内存单元空间，而线性表无此要求 （2）线性表的元素是逻辑意义上不可再分的元素，而数组中的每个元素还可以是一个数组 （3）数组的操作主要是向某
两个list取交集_刷题之路第四题--取两个顺序数组的数值的中位数
weixin_39847244的博客
12-05 220
Median of Two Sorted Arrays简介：取两个顺序数组的数值的中位数问题详解：给定两个排序的数组nums1和nums2分别为m和n,我们需要的是两个数组中所组成一个数列的中位数.注意：1.需要判断数组NPE2.结果不是int举例1:nums1 = [1, 3]nums2 = [2]中位数是 2.02:nums1 = [1, 2]nums2 = [3, 4]中位数是 (2 + 3...
结构数组
qq_45838321的博客
02-29 641
一.定义 数组的元素类型为结构类型时，称为结构数组。 例. struct employee {int a; double x; }; employee c[10]; c[10]是一个有10个元素的数组，其中元素类型是employee类型。数组中的每一个元素包含两个数据成员。 c[0].a c[0].x c[1].a c[1].x … c[9].a ...
【数据结构】-- 定义结构体数组
weixin_44367884的博客
12-10 1038
#include <stdio.h> #include <stdlib.h> // 定义结构体 typedef struct{ char *name; int age; }Student; // 结构体数组输入 void inputStructArray(Student students[],int size){ int i=0; ...
数据结构数组基本操作
09-20
数组是一种线性数据结构，由相同类型的元素组成，每个元素可以通过下标（索引）来访问。以下是数组的基本操作： 1. 创建数组：声明数组的类型和大小。 2. 初始化数组：为数组的每个元素赋初值。 3. 访问数组元素...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

叫我剑锋

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

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

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

打赏作者

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

抵扣说明：

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

余额充值