数据结构-顺序表JAVA

	顺序表：顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储，在数组上完成数据的增删改查
	顺序表一般分为静态顺序表和动态顺序表

顺序表基本操作JAVA实现
// 顺序表的元素类型 int
public class MyArrayList {
// 属性是什么
private int[] array; // 代表的是存在数据的数组
// array.length 代表的是数组的容量
private int size; // 记录顺序表的已有数据个数

// 构造方法
public MyArrayList() {
	// 1. 申请空间
	array = new int[2];
	// 2. 初始化数据个数（ensureCapacity在申请空间不够时进行扩容）
	size = 0;
}

// 增（重点）
// 平均时间复杂度 O(1)
public void pushBack(int element) {
	ensureCapacity();
	array[size++] = element;
}

//头插
//判断大小->元素后移->进行头插
public void pushFront(int element) {
	ensureCapacity();
	for (int i = size; i >= 1; i--) {
		array[i]  = array[i - 1];
	}
	
	array[0] = element;
	size++;
}


//指定下标插入指定元素
//传入下标和值->找下标->下标及之后的元素后移->插入待插值->size++
public void insert(int index, int element) {
	if (index < 0 || index > size) {
		System.err.println("下标错误");
		return;
	}
	
	ensureCapacity();
	
	for (int i = size - 1; i >= index; i--) {
		array[i + 1] = array[i];
	}
	array[index] = element;
	size++;
}

// 删（重点)
public void popBack() {
	if (size <= 0) {
		System.err.println("顺序表为空");
		return;
	}
	array[--size] = 0;
}

public void popFront() {//删前判断表空，为空不能删
	if (size <= 0) {
		System.err.println("顺序表为空");
		return;
	}
	
	for (int i = 0; i < size - 1; i++) {
		array[i] = array[i + 1];
	}
	
	array[--size] = 0;
}

public void earse(int index) {
	if (size <= 0) {
		System.err.println("顺序表为空");
		return;
	}
	
	if (index < 0 || index >= size) {
		System.err.println("下标错误");
		return;
	}
	
	for (int i = index + 1; i < size; i++) {
		array[i - 1] = array[i];
	}
	
	array[--size] = 0;
}

// 查
// 改
// 打印
public void print() {
	System.out.println("打印顺序表: 当前容量: " + array.length);
	for (int i = 0; i < size; i++) {
		System.out.print(array[i] + " ");
	}
	System.out.println();
}

// 保证容量够用，否则进行扩容
private void ensureCapacity() {
	if (size < array.length) {
		return;
	}
	
	int newCapacity = array.length * 2;
	int[] newArray = new int[newCapacity];
	for (int i = 0; i < size; i++) {
		newArray[i] = array[i];
	}
	array = newArray;
}

public static void main(String[] args) {
	MyArrayList list = new MyArrayList();
	list.print();
	list.pushBack(1);
	list.pushBack(2);
	list.pushBack(3);
	list.print();	// 1 2 3
	list.pushFront(10);
	list.pushFront(20);
	list.pushFront(30);
	list.print();	// 30 20 10 1 2 3
	list.insert(3, 100);
	list.print();	// 30 20 10 100 1 2 3
	list.insert(20, 200);	// 报错
	
	list.earse(2);
	list.earse(2);
	list.print();	// 30 20 1 2 3
	list.popFront();
	list.popFront();
	list.popFront();
	list.print();	// 2 3
	list.popBack();
	list.popBack();
	list.print();	// 空的
	list.popBack();	// 报错
}

}

程序运行结果：

数组容量及扩容问题：
数组容量（array.length）和已有数据个数（size）的关系
1）数组额用量够用：array.length>size
2）数组容量不够用（扩容1.5倍）
【1.5解释：扩容的空间越小，浪费的空间越少；扩容的空间越大，需要扩容的次数越少】
【扩容：可以理解为搬家：申请更大空间->数据复制】