数据结构之数组

思考题

• 为什么很多计算机编程语言中数组的下标要从0开始呢？

定义一个数组一定会分配内存空间。数组的特点是 内存是一段连续的地址。
int a[] = new int[3];
到内存中申请空间：10001,10002,10003

存数据

a[0] => 10001 ====> 10001+0typesize
a[1] => 10002 =====> 10001+1typesize
a[2]=> 10003 =====> 10001+2*typesize

如果我们不从0开始

a[1] = 10001+(1-1)
a[2] = 10001+(2-1)
a[3] = 10001+(3-1)
这样多了一次计算，是有消耗的

什么是数组

1. 数组定义：

数组是用于储存多个相同类型数据的集合
通常用Array表示，也称之为线性表

2. 特点

(1)数组是相同数据类型的元素的集合。
(2)数组中的各元素的存储是有先后顺序的，它们在内存中按照这个先后顺序连续存放在一起。内存地址
(3)数组元素用整个数组的名字和它自己在数组中的顺序位置来表示。例如，a[0]表示名字为a的数组中的第一个元素，a[1]代表数组a的第二个元素，以此类推。

3. 表现形式

一维数组：Int a[],String a[]
多维数组：Int a[][],int a[][][]。 int a[m][n]:内存空间是多少？ m*n

4. 随机访问【重要应用：查找，面试重点】

数组是连续的内存空间和相同类型的数据。正是因为这两个限制，它才有了一个非常重要的特性：随机访问。但有利就有弊，这两个限制也让数组的很多操作变得非常低效，比如要想在数组中删除、插入一个数据，为了保证连续性，就需要做大量的数据搬移工作。

5. 数组的缺点：插入和删除

设数组的长度为n，现在，如果我们需要将一个数据插入到数组中的第k个位置。删除第N个位置的数据
思路：将低k个位置后的数据向前移动一个位置，并开辟一个新数组size-1，将原始数据复制到新数组

6. 使用数组一定要注意访问越界问题

ArrayList和数组

本质是一样的，都是数组。ArrayList是JDK封装了，不需要管扩容等操作
数组的话就要你全部操作

两者之间应该如何选用？

1. 不知道数据大小的肯定选ArrayList
2. 如果你知道数据的大小而且你又非常关注性能那就用数组

数组最需要注意的就是越界：所以一定要多加判断，尤其是在开始和结束。测试的时候也一样注意头和尾

堆栈内存

Java里面的内存分为几种？
什么是堆内存？：存放new创建的对象和数组
什么是栈内存？引用变量
堆栈都用Java用来存放数据的地方，与C++ / c不一样。java自动管理我们的堆栈。gc，new出来的你没管过
堆栈的区别：

1. 栈的速度要快
2. 栈内存的数据可以共享，主要存一些基本数据类型

int a = 3; //在栈中创建变量a 然后给a赋值，先不会创建一个3而是先在栈中找有没有3，如果有直接指向。如果没有就加一个3进来

编程题

寻址公式

1. 思考一下二维数组的内存地址是怎么样的？写出寻址公式

a[] = new int[10]; ==> loc = init_loc(初始内存地址)+index(数组的下标)*size(数据的长度)
a[2][3]二维=>转化一维a[6] 如
1 2 3
4 5 6
转化为 1 2 3 4 5 6
4的下标在二维里边是(1,0)在一维是第三个=> i(二维所在行)n(一维长度)+j（二维所在列）= 13+0=3

总结：数组是一个最基础最简单的数据结构，必须要完全搞懂。它是存储相同类型的一组数据，最大的两个特点就是下标和随机访问。缺点就是插入和删除是很慢的，时间复杂度为O（n）

统计年龄

2. 给你一个文件里面包含全国人民（14亿）的年龄数据（0~180），现在要你统计每一个年龄有多少人？给定机器为 单台+2CPU+2G内存。不得使用现成的容器，比如map等。

在以上情况下你该如何以最高效的方法来解决这个问题？

排序算法：想过没？能不能解决这个问题？：不能 为什么？
排序的最高效算法：O(nlogn) 14亿，排不出来，而且内存也不够
通过数组怎么解决？下标赋予含义
int a[] = new int[180];a[0]++;0表示的是0岁，a[0]的值表示的就是0有多少人

下标：数组最优一个特点。这里可以通下标表示成有意义的数据，不只是数据里面的标记，年龄和下标对应。随机访问：可以直接通过下标定位到数组中的某一个数据

生成14亿数据：

	public static void main(String[] args) throws Exception {
		final String fileName = "D:\\ages.txt";
		final Random random = new Random();
		BufferedWriter objWriter = null;
		objWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(fileName)));
		for (int i = 0; i < 1400000000; i++) {
			int age = Math.abs(random.nextInt()) % 180;
			objWriter.write(age + "\r\n");
		}
		objWriter.flush();
		objWriter.close();

	}

统计年龄

public static void main(String[] args) throws Exception {
    String fileName = "D:\\ages.txt";
    // 一行一行读取
    BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(fileName),"UTF-8"));
	String ageStr = null;
    int ages [] = new int[180];
    int tot = 0 ;	// 记录数据量
    while((ageStr = br.readLine()) != null){
        int age = Integer.valueOf(ageStr);
        ages[age] ++;
        tot ++;
    }
    //O(n) 14亿. 100万/秒 *1000 = 10亿 100~1000s之间 => 500s以下 60*8=480s
	System.out.println("总共的数据大小: " + tot);
    for(int i = 0 ; i < 200 ; i ++){//下标从0开始的
        System.out.println(i + ":" + data[i]);
    }
}

实现一个ArrayList

分析ArrayList必要的属性和操作

package array;

import java.util.Arrays;

/**
 * @author zw
 * @create 2023-03-21 23:34
 */
public class MyArrayList<T> {

    // 存储数据的数组
    private Object data[];
    // 数组长度
    private int size = 10;
    // 当前已存在数据的末尾坐标
    private int lastIndex = 0;
    // 扩容因子
    private final double DILATANCY_FACTOR = 0.75d;


    public MyArrayList() {        //数组的初始化过程
        data = new Object[size];        //分配的内存空间{0,0,0,0,0}
    }

    public MyArrayList(int size) {        //数组的初始化过程
        this.size = size;
        data = new Object[size];        //分配的内存空间{0,0,0,0,0}
    }

    /**
     * 在末尾插入数据
     *
     * @param o
     */
    private void insert(Object o) {
        // 添加判断是否越界，满足条件则未越界
        int tmpLastIndex = lastIndex;
        if (++lastIndex > size * DILATANCY_FACTOR) {
            // 扩容，会把size*2
            grow();
        }
        data[tmpLastIndex] = o;

    }

    /**
     * 指定位置插入
     *
     * @param o   插入数据
     * @param loc 指定下标位置
     */
    private void insert(Object o, int loc) throws Exception {
        // 判断是否越界
        if (loc > lastIndex) {
            throw new Exception("数组下标越界");
        }
        // 添加判断是否越界，满足条件则未越界
        if (++lastIndex > size * DILATANCY_FACTOR) {
            // 扩容，会把size*2
            grow();
        }
        // 将指定位置及之后的数据后移动，两种遍历方式
        // 从n位置从前往后遍历到index【这种方式复杂】
        // 从index位置从后往前遍历到n
        for (int i = lastIndex; i > loc; i--) {
            data[i] = data[i - 1]; // 数据后移
        }
        data[loc] = o; // 给插入位置赋值
    }

    /**
     * 扩容
     */
    private void grow() {
        int oldSize = data.length;
        int newSize = oldSize << 1;
        data = Arrays.copyOf(data, newSize);
        size = newSize;
    }


    /**
     * 删除指定位置元素
     *
     * @param loc 删除位置
     */
    private void delete(int loc) throws Exception {
        // 判断是否越界
        if (loc > lastIndex) {
            throw new Exception("数组下标越界");
        }
        // 删除的是最后一个元素，无需移动数据
        else if (loc == lastIndex) {
            data[lastIndex] = null;
        } else {
            // 删除当前位置数据，并将当前位置数据之后的数据前移动
            for (int i = loc; i < lastIndex; i++) {
                data[i] = data[i + 1];
            }
            // 最后一个位置的的数据无用了,数据回收
            data[lastIndex] = null;
        }

        // 判断是否缩容
        //if (--lastIndex < (size >> 1)) {
        //    atrophy();
        //}
    }

    /**
     * 缩容
     */
    private void atrophy() {
        int oldSize = data.length;
        int newSize = oldSize >> 1;
        data = Arrays.copyOf(data, newSize);
        size = newSize;
    }

    /**
     * 更新指定位置数据
     *
     * @param o
     * @param loc
     */
    private void update(Object o, int loc) {
        data[loc] = o;
    }

    /**
     * 获取指定位置数据
     *
     * @param index
     * @return
     */
    private T get(int index) throws Exception {
        // 判断是否越界
        if (index > lastIndex) {
            throw new Exception("数组下标越界");
        }
        return (T) data[index];
    }

    public void print() {
        StringBuffer sb = new StringBuffer();
        sb.append("lastIndex=").append(lastIndex).append("\r\n");
        sb.append("size=").append(size).append("\r\n");
        if (lastIndex == 0) {
            System.out.println("[]");
            return;
        }

        sb.append("[");
        for (int i = 0; i < lastIndex; i++) {
            sb.append(data[i]);
            if (i != lastIndex - 1) sb.append(",");
        }
        sb.append("]");
        System.out.println(sb.toString());
    }
}

测试

    public static void main(String[] args) throws Exception{
        MyArrayList<Integer> list = new MyArrayList<Integer>();
        for (int i = 0; i < 8; i++) {
            list.insert(i);
        }
        list.print();
        list.insert(100,1);
        list.update(200,2);
        list.print();
        for (int i = 0; i < 8; i++) {
            list.delete(0);
        }
        list.print();
    }

运行结果

lastIndex=8
size=20
[0,1,2,3,4,5,6,7]
lastIndex=9
size=20
[0,100,200,2,3,4,5,6,7]
lastIndex=9
size=20
[6,7,null,null,null,null,null,null,null]

lastIndex=8
size=20
[0,1,2,3,4,5,6,7]
lastIndex=9
size=20
[0,100,200,2,3,4,5,6,7]
lastIndex=2
size=5
[6,7]