一.数组的概念
数组(Array)是一种线性表数据结构。它用一组连续的内存空间,来存储一组具有相同类型的数据。如下图所示:
二.数组的特点
1.数组根据下标随机访问,时间复杂度为O(1)。
2.数据的插入和删除和低效。
- 如果插入/删除数组末尾的数据,最好情况时间复杂度为 O(1)
- 如果插入/删除开头的数据,则最坏情况时间复杂度为 O(n)
- 平均情况时间复杂度也为 O(n)。
三.什么时候使用数组?
1.数据大小已知,并且对数据的操作简单。
2.当表示多维数组时,用数组比较直观,Object[][] 表示比较直观。
四.数组下标为什么从0开始?
从数组的存储模型上来看,“下标”最确切的定义应该是“偏移量(offset)”。
如果用a代表数组的首地址,a[0]就是偏移量为0的位置,也就是首地址,a[k]就表示偏移量k个 type_size 的位置,所以计算 a[k] 的内存地址只需要用这个公式:
a[k]_address = base_address + k * type_size
但是,如果数组从 1 开始计数,那我们计算数组元素 a[k] 的内存地址就会变为:
a[k]_address = base_address + (k-1) * type_size
如果从 1 开始编号,每次随机访问数组元素都多了一次减法运算,对CPU来说就是多了一次减法指令。
五.Java数组简单实现
/**
* 使用范型 不可以是基本数据类型,只能是类对象
* boolean byte char short int long float double
* 基本数据类型都有对应的包装类
* Boolean Byte Char Short Integer Long Float Double
*
* @author 一直往前走
* @date
*/
public class Array<E> {
/**
* 数组
*/
private E[] data;
/**
* 有效元素个数
*/
private int size;
/**
* 构造函数,传入数组的容量capacity构造Array
*
* @param capacity 容量
*/
public Array(int capacity) {
//范型数组 Object[]
data = (E[]) new Object[capacity];
size = 0;
}
/**
* 构造函数,传入数组arr 初始化构造Array
* @param capacity 容量
*/
public Array(E[] arr) {
data = (E[]) new Object[arr.length];
for (int i = 0; i < arr.length; i++) {
data[i] = arr[i];
}
size = arr.length;
}
/**
* 默认构造函数 capacity 默认10
*/
public Array() {
this(10);
}
/**
* 获取数组中的元素个数
*
* @return
*/
public int getSize() {
return size;
}
/**
* 获取数组的容量
*
* @return
*/
public int getCapacity() {
return data.length;
}
/**
* 数组是否为空
*
* @return
*/
public boolean isEmpty() {
return size == 0;
}
/**
* 向数组末尾添加元素 等同于向索引size添加元素 维护size -> size++
*
* @param e
*/
public void addLast(E e) {
add(size, e);
}
/**
* 向数组第一个位置添加元素
*
* @param e
*/
public void addFirst(E e) {
add(0, e);
}
/**
* 向指定位置添加元素index, index和之后的所有数据都要往后挪一位 从最后一位开始移动 从右至左
*
* @param index 索引位置
* @param e 添加的元素
*/
public void add(int index, E e) {
//TODO 此处需要留意index > size
if (index < 0 || index > size) {
throw new IllegalArgumentException("AddLast failed. Require index >=0 and index <= size");
}
if (size == data.length) {
resize(2 * data.length);
}
//从最后一个位置开始移动赋值 这里的时间复杂度最差为O(n)
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
data[index] = e;
size++;
}
/**
* 获取ndex索引位置的元素
*
* @param index
* @return
*/
public E get(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get failed.Index is illegal");
}
return data[index];
}
public E getLast() {
return get(size - 1);
}
public E getFirst() {
return get(0);
}
/**
* 修改index索引位置的元素为e 时间复杂度为O(1)
*
* @param index
* @param e
*/
public void set(int index, E e) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Get failed.Index is illegal");
}
data[index] = e;
}
/**
* 查找数组元素e所在的索引,如果不存在元素e,则返回-1 时间复杂度为O(n)
*
* @param e
* @return
*/
public int find(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
return i;
}
}
return -1;
}
/**
* 交换两个索引位置的数据
*
* @param i
* @param j
*/
public void swap(int i, int j) {
if (i < 0 || i >= size || j < 0 || j >= size) {
throw new IllegalAccessError("index is illegal");
}
E t = data[i];
data[i] = data[j];
data[j] = t;
}
/**
* 查找数组元素e所在的索引,如果不存在元素e,则返回-1
*
* @param e
* @return
*/
public String findAll(E e) {
StringBuilder sb = new StringBuilder();
sb.append("[");
int[] arr = new int[size];
int j = 0;
for (int i = 0; i < size; i++) {
if (data[i].equals(e)) {
arr[j++] = i;
sb.append(i + ",");
}
}
sb.append("]");
return sb.toString();
}
/**
* 删除指定位置元素 index后面的前移一位 返回删除的元素 时间复杂度为O(n)
*
* @return
*/
public E remove(int index) {
if (index < 0 || index >= size) {
throw new IllegalArgumentException("Remove failed.Index is illegal");
}
E ret = data[index];
for (int i = index + 1; i < size; i++) {
data[i - 1] = data[i];
}
size--;
data[size] = null;//闲散的对象 垃圾回收 Lazy缩容
if (size == data.length / 4 && data.length / 2 != 0)
resize(data.length / 2);
return ret;
}
/**
* 扩容
*
* @param newCapatity
*/
private void resize(int newCapatity) {
E[] newData = (E[]) new Object[newCapatity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
//data 指向新的空间
data = newData;
}
/**
* 删除第一个元素
*
* @return
*/
public E removeFirst() {
return remove(0);
}
/**
* 删除最后一个元素
*
* @return
*/
public E removeLast() {
return remove(size - 1);
}
public void removeElement(E e) {
int index = find(e);
if (index != -1) {
remove(index);
}
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(String.format("Array:size=%d,capatity=%d\n", size, data.length));
sb.append("[");
for (int i = 0; i < size; i++) {
sb.append(data[i]);
if (i != size - 1)
sb.append(", ");
}
sb.append("]");
return sb.toString();
}
}