数据结构----线性表、顺序表、模拟实现顺序表
文章目录
- 1. 线性表
- 2. 顺序表
- 3. 模拟实现顺序表
1. 线性表
线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，指具有相同数据类型的元素按照一定的顺序排列的数据结构，其中每个元素都有唯一的前驱元素和后继元素（除了第一个元素没有前驱，最后一个元素没有后继），常见的线性表：顺序表、链表、栈、队列…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
2. 顺序表
顺序表是一种线性表的存储结构，它是由一组地址连续的存储单元依次存储线性表中的元素，元素之间的逻辑关系和物理关系是一致的。顺序表可以通过数组来实现，在数组上完成数据的增删查改。
顺序表的主要特点是：
- 元素之间的逻辑关系和物理关系是一致的，即顺序表中的元素在内存中是连续存储的。
- 可以通过下标直接访问和修改元素，因此支持随机访问。
- 具有固定的容量，需要预先分配足够的内存空间来存储元素，如果需要动态调整大小，可能需要重新分配内存空间并进行元素的复制。
- 元素的插入和删除操作可能需要移动其他元素来保持顺序，因此效率较低。
顺序表在实际应用中有着广泛的应用，例如数组就是一种顺序表的实现方式。在计算机科学中，顺序表也是一种重要的数据结构，用于存储和操作线性表中的元素。
3. 模拟实现顺序表
下面是我写的一个基于数组实现的顺序表(MyArrayList)的完整代码，包含了每个方法的实现：
【IList.clss】:
模拟List接口，里面记录了MyArrayList需要实现的方法
public interface IList {
// 新增元素,默认在数组最后新增
public void add(int data);
// 在 pos 位置新增元素
public void add(int pos, int data);
// 判定是否包含某个元素
public boolean contains(int toFind);
// 查找某个元素对应的位置
public int indexOf(int toFind);
// 获取 pos 位置的元素
public int get(int pos);
// 给 pos 位置的元素设为 value
public void set(int pos, int value);
//删除第一次出现的关键字key
public void remove(int toRemove);
// 获取顺序表长度
public int size();
// 清空顺序表
public void clear();
// 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
public void display();
}
【MyArrayListEmpty.clss】:
自定义异常数组为空异常（运行时异常）
public class MyArrayListEmpty extends RuntimeException{
public MyArrayListEmpty(String msg) {
super(msg);
}
}
【PositionIllegal.clss】:
自定义异常数组下标非法（运行时异常）
public class PositionIllegal extends RuntimeException{
public PositionIllegal(String msg) {
super(msg);
}
}
【PositionOutOfBounds .clss】:
自定义异常数组访问元素时下标越界（运行时异常）
public class PositionOutOfBounds extends RuntimeException {
public PositionOutOfBounds(String msg) {
super(msg);
}
}
【MyArrayList.class】：
public class MyArrayList implements IList {
int[] elements;//用来存放数据元素
int usedSize;//代表当前顺序表中的有效数据个数
public static final int DEFAULT_SIZE = 2;//默认的数组中的数据的个数
// 默认构造方法
public MyArrayList() {
this.elements = new int[DEFAULT_SIZE];//默认初始大小
}
// 将顺序表的底层容量设置为initCapacity
public MyArrayList(int initCapacity) {
this.elements = new int[initCapacity];//自定义大小
}
@Override
public void display() {
for (int i = 0; i < this.usedSize; i++) {
System.out.print(this.elements[i] + " ");
}
System.out.println();
}
@Override
public void add(int data) {
//扩容
checkCapacity();
//添加数组
this.elements[this.usedSize] = data;
//有效数据个数加一
this.usedSize++;
}
private boolean isFull() {
//1.检查数组是否满了
if (this.usedSize == elements.length) {
return true;
}
return false;
}
private void checkCapacity() {
//2.检查数组容量并进行扩容
if (isFull()) {
// 数组容量扩大二倍
this.elements = Arrays.copyOf(elements, 2 * (this.elements.length));
}
}
@Override
public void add(int pos, int data) {
//1.检查数组元素下标是否合法
checkPositionIllegalOnAdd(pos);
//2.检查数组的容量
checkCapacity();
//3.将数据存放在对应要存放的位置
for (int i = this.usedSize - 1; i >= pos; i++) {
this.elements[i + 1] = this.elements[i];
}
this.elements[pos] = data;
this.usedSize++;
}
@Override
public boolean contains(int toFind) {
//1.判断数组是否为空
isEmpty();
//2.判断数组中是否含有该元素
for (int i = 0; i < this.usedSize; i++) {
if (this.elements[i] == toFind) {
return true;
}
}
return false;
}
@Override
public int indexOf(int toFind) {
//1.判断数组是否为空
isEmpty();
//2.判断数组中是否含有该元素
for (int i = 0; i < this.usedSize; i++) {
if (this.elements[i] == toFind) {
return i;
}
}
//3.数组中不含有该元素，返回值为-1
return -1;
}
@Override
public int get(int pos) {
//检查数组下标是否越界
checkPositionGetAndSet(pos);
//判断数组是否为空
isEmpty();
//得到下标对应的值
int ret = this.elements[pos];
return ret;
}
@Override
public void set(int pos, int value) {
//检查数组下标是否越界
checkPositionGetAndSet(pos);
//判断数组是否为空
isEmpty();
//设置下标对应的值
this.elements[pos] = value;
}
@Override
public void remove(int toRemove) {
//获取要删除的元素对应的下标
int index = indexOf(toRemove);
//判断下标
if (index != -1) {
//将index之后的所有元素向前移动一位
for (int i = index; i < this.usedSize - 1; i++) {
this.elements[i] = this.elements[i + 1];
}
//删除元素之后，数组计数器减一
this.usedSize--;
}
}
@Override
public int size() {
return this.usedSize;
}
@Override
public void clear() {
this.usedSize = 0;
}
private void checkPositionIllegalOnAdd(int pos) throws PositionIllegal {
//存放数据的合法位置为 ：0 ~ usedSize
if (pos < 0 || pos > this.usedSize) {
throw new PositionIllegal("数组的下标" + pos + "不合法");
}
}
private void checkPositionGetAndSet(int pos) {
if (pos < 0 || pos >= this.usedSize) {
throw new PositionOutOfBounds("数组下标" + pos + "越界");
}
}
public void isEmpty() {
if (this.usedSize == 0) {
throw new MyArrayListEmpty("该数组为空");
}
}
}
【讲解部分一】：
private void checkCapacity() {
//2.检查数组容量并进行扩容
if (isFull()) {
// 数组容量扩大二倍
this.elements = Arrays.copyOf(elements, 2 * (this.elements.length));
}
}
Arrays.copyOf ( ) 方法是Java中用于复制数组的方法。它可以复制指定数组的所有元素到一个新数组中，并返回新数组。 Arrays.copyOf ( ) 方法有两个参数：源数组和目标数组的长度。
下面是 Arrays.copyOf ( ) 方法的语法：
public static <T> T[] copyOf(T[] original, int newLength)
其中，original是源数组，newLength是目标数组的长度。返回的数组类型与源数组类型相同。需要注意的是， Arrays.copyOf ( ) 方法会根据目标数组的长度进行复制。如果目标数组长度小于源数组长度，复制结果将截取源数组的前部分元素；如果目标数组长度大于源数组长度，复制结果将在末尾填充默认值 0 。
【讲解部分二】：
public boolean contains(int toFind) {
//1.判断数组是否为空
isEmpty();
//2.判断数组中是否含有该元素
for (int i = 0; i < this.usedSize; i++) {
if (this.elements[i] == toFind) {
return true;
}
}
return false;
}
如果里面的每一个元素都是引用类型，需要使用equals（）来进行比较，如果是自定义类型，还需要自己覆盖equals（）方法。
public boolean contains(int toFind) {
//1.判断数组是否为空
isEmpty();
//2.判断数组中是否含有该元素
for (int i = 0; i < this.usedSize; i++) {
if (this.elements[i].equals(toFind)) {
return true;
}
}
return false;
}
【讲解部分三】：
public void remove(int toRemove) {
//获取要删除的元素对应的下标
int index = indexOf(toRemove);
//判断下标
if (index != -1) {
//将index之后的所有元素向前移动一位
for (int i = index; i < this.usedSize - 1; i++) {
this.elements[i] = this.elements[i + 1];
}
//删除元素之后，数组计数器减一
this.usedSize--;
}
}
如果里面的每一个元素都是引用类型，需要对最后一个元素设置为null，如果不这样做，那么你对最后一个对象的引用将遗留而造成内存泄漏。
【讲解部分四】：
public void clear() {
this.usedSize = 0;
}
如果数组中每一个元素都是引用类型，将this.usedSize = 0;时，会发生内存泄露，原因是JVM只有当对象没有被引用时，才会进行对象回收，this.usedSize = 0;时并没将元素置为null，顺序表仍然引用对象，JVM无法进行回收。
方式一：
public void clear() {
this.element= null;
this.usedSize = 0;
}
较为暴力，不推荐
方式二：
public void clear() {
for(int i = 0;i < this.usedSize;i++){
this.element[i] = null;
}
this.usedSize = 0;
}
比较建议，使用垃圾回收器（GC）进行回收