Java实现数据结构---数组

概念

数组是（Array）是有限个相同类型的变量所组成的有序集合，数组中的每一个变量为称为元素。数组是最简单、最常用的数据结构。

数组下标从零开始。

存储原理

数组用一组连续的内存空间来存储一组具有相同类型的数据。

注: 灰色格子–被使用的内存; 橙色格子–空闲的内存; 红色格子–数组暂用的内存。

数组的操作

1. 数组演示类:

package com.xxliao.datastructure.linerar_list.array;

import javax.sql.XADataSource;
/**
 1. @author xxliao
 2. @description: 数据结构 - 线性表 - array
 3.  数组是（Array）是 有限个相同类型 的变量所组成的 有序 集合，数组中的每一个变量为称为元素。数组是最简单、最常用的数据结构。

 数组是用一组 连续的内存空间 来存储一组具有 相同类型 的数据。
 4.  5. @date 2024/5/27 22:50
 */
public class Array {

    // 定义数组
    int[] array = new int[10];

    // 定义计数器
    int count = 0;

    // 初始化，填充0-4空间的值
    public Array() {
        array[0] = 3;
        array[1] = 1;
        array[2] = 2;
        array[3] = 5;
        array[4] = 4;
        count = 5;
    }

    /**
     * @description  根据索引获取元组的值
     * @author  xxliao
     * @date  2024/5/28 11:35
     */
    public int get(int index) {
        return array[index];
    }

    /**
     * @description  修改元素
      index: 索引
      value: 值
     * @author  xxliao
     * @date  2024/5/28 11:36
     */
    public void update(int index, int value) {
        array[index] = value;
    }

    /**
     * @description  从数组尾部添加
     * @author  xxliao
     * @date  2024/5/28 11:38
     */
    public void insertTail(int value) {
        if(count >= array.length) { //判断是否扩容
            resize();
        }
        array[count++] = value;
    }

    /**
     * @description  从中间添加
     * @author  xxliao
     * @date  2024/5/28 11:42
     */
    public void insertMiddle(int index, int value) {
        if(count >= array.length) { // 判断是否扩容
            resize();
        }
        for (int i = array.length-1; i >= index; i--) {
            // 从尾部开始遍历，看是否有值，有值就移动。
            if (array[i] != 0) {
                array[i+1]=array[i];
            }
        }
        array[index]=value;
        count++;
    }

    /**
     * @description  扩容，增加一倍空间
     * @author  xxliao
     * @date  2024/5/28 11:45
     */
    public void resize(){
        int[] numsNew=new int[array.length*2];
        System.arraycopy(array,0,numsNew,0,array.length);
        array=numsNew;
    }

    /**
     * @description  删除元素，并移动
     * @author  xxliao
     * @date  2024/5/28 11:47
     */
    public void deleteMiddle(int index){
        for(int i=index+1;i<array.length;i++){
            array[i-1] = array[i];
        }
        count--;
    }

    /**
     * @description  遍历数组
     * @author  xxliao
     * @date  2024/5/28 11:48
     */
    public void display() {
        for (int value : array) {
            System.out.print(value+" ");
        }
        System.out.println("=====================");
    }

    /**
     * @description  遍历数组
     * @author  xxliao
     * @date  2024/5/28 11:48
     */
    public void display2() {
        for (int i = array.length - 1; i >= 0; i--) {
            System.out.print(array[i]+" ");
        }
        System.out.println("=====================");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

2. 测试类

package com.xxliao.datastructure.linerar_list.array;

/**
 1. @author xxliao
 2. @description: array test client
 3. @date 2024/5/28 11:33
 */
public class TestClient {

    public static void main(String[] args) {
        Array array = new Array();
        array.display();

        // 测试尾部添加
        // for (int i = 0; i < 10; i++) {
        //   array.insertTail(i);
        // }

        // 测试中间添加
        array.insertMiddle(1,1000);

        // 测试删除
        //array.deleteMiddle(3);

        array.display();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

3. 输出结构

数组尾部添加:

数组中间添加:

数组删除:

完整代码

https://github.com/xxliao100/datastructure_algorithms.git