Java数据结构：快速了解顺序表以及实现
文章目录
- 一、 顺序表
-
- 1. 顺序表的概念
- 2. 顺序表的分类
- 3. 顺序表的实现
-
- (1) 创建类
- (2) 新增元素
- (3) 打印顺序表
- (4) 判读是否包含某个元素
- (5) 查找元素对应的位置
- (6) 获取pos位置的元素
- (7) 修改 pos位置的元素
- (8) 删除第一次出现的元素
- (9) 获取顺序表长度
- (10) 清空顺序表
- 二、顺序表实现代码汇总
- 三、顺序表的优点和缺点
-
- 1.顺序表的优点
- 2.顺序表的缺点
- 总结
一、 顺序表
1. 顺序表的概念
什么顺序表？顺序表其实就是一个数组但和数组还是有一点区别，区别主要是在操作逻辑上。
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
2. 顺序表的分类
顺序表一般可以分为：
- 静态顺序表：使用定长数组存储。
- 动态顺序表：使用动态开辟的数组存储。
静态顺序表适用于确定知道需要存多少数据的场景.
静态顺序表的定长数组导致N定大了，空间开多了浪费，开少了不够用.
相比之下动态顺序表更灵活, 根据需要动态的分配空间大小.
3. 顺序表的实现
这里只是简单用 int类型 实现一下顺序表的思路。
(1) 创建类
我这创建了一个MyArrayList 类来实现顺序表的增删查改。
先是定义了一个elem的数组的引用和一个usedSize实例成员变量，还有一个构造方法在示例化的对象的同时给数组开辟空间。
public class MyArrayList {
public int[] elem;//只是定义了一个引用
public int usedSize;//有效的数据个数
public MyArrayList () {
//初始化一个数组
this.elem = new int[5];
}
}
(2) 新增元素
新增元素要考虑：
1.位置合法性
2.判读数组是否满了，满了则需要增容
这里的扩容用到了copyOf函数，拷贝了原数组并把原数组扩容了2倍再用elem这个引用指向这个新的数组
//增容判断
public boolean isFull() {
if(this.elem.length == this.usedSize){
return true;
}
return false;
}
// 在 pos 位置新增元素
public void add(int pos, int data) {
//判断是否需要增容
if(this.isFull()) {
this.elem = Arrays.copyOf(this.elem,this.elem.length*2);
}
//判断pos位置合法性
if (pos < 0 || pos > this.usedSize) {
System.out.println("pos位置不合法");
return;
}
//从后往前挪元素
for (int i = this.usedSize; pos < i; i--) {
this.elem[i+1] = this.elem[i];
}
this.elem[pos] = data;
this.usedSize++;
}
(3) 打印顺序表
for循环遍历整个顺序表，usedSize是元素个数
// 打印顺序表
public void display() {
for (int i = 0; i < this.usedSize; i++) {
System.out.print(this.elem[i]+" ");
}
System.out.println();
}
(4) 判读是否包含某个元素
遍历顺序表，如果包含返回 true 否则返回 false
// 判定是否包含某个元素
public boolean contains(int toFind) {
for (int i = 0; i < this.usedSize; i++) {
if(this.elem[i] == toFind) return true;
}
return false;
}
(5) 查找元素对应的位置
找到返回下标，没找到返回 -1
// 查找某个元素对应的位置
public int search(int toFind) {
for (int i = 0; i < this.usedSize; i++) {
if(this.elem[i] == toFind) return i;
}
return -1;
}
(6) 获取pos位置的元素
先判断pos位置的合法性，合法则返回pos位置的元素
// 获取 pos 位置的元素
public int getPos(int pos) {
//判断合法性
if(pos < 0 || pos >= this.usedSize) {
System.out.println("pos位置不合法");
return -1;
}
return this.elem[pos];
}
(7) 修改 pos位置的元素
先判断pos位置合法性，合法则修改pos位置的元素
// 给 pos 位置的元素设为 value
public void setPos(int pos, int value) {
//判断合法性
if(pos < 0 || pos >= this.usedSize) {
System.out.println("pos位置不合法");
return;
}
this.elem[pos] = value;
}
(8) 删除第一次出现的元素
调用前面的search方法判断顺序表中是否有该元素，再把要删除的元素的元素往前挪，把要删除的元素覆盖。
//删除第一次出现的关键字key
public void remove(int key) {
int ret = search(key);
if(ret == -1) {
System.out.println("关键字key不存在");
return;
}
for (int i = ret; i < this.usedSize-1; i++) {
this.elem[i] = this.elem[i+1];
}
this.usedSize--;
}
(9) 获取顺序表长度
// 获取顺序表长度
public int size() {
return this.usedSize;
}
(10) 清空顺序表
// 清空顺序表
public void clear() {
this.usedSize = 0;
}
二、顺序表实现代码汇总
import java.util.Arrays;
/**
* 简单的顺序表思路
*/
public class MyArrayList {
public int[] elem;//只是定义了一个引用
public int usedSize;//有效的数据个数
public MyArrayList () {
//初始化一个数组
this.elem = new int[5];
}
//增容判断
public boolean isFull() {
if(this.elem.length == this.usedSize){
return true;
}
return false;
}
// 在 pos 位置新增元素
public void add(int pos, int data) {
//判断是否需要增容
if(this.isFull()) {
this.elem = Arrays.copyOf(this.elem,this.elem.length*2);
}
//判断pos位置合法性
if (pos < 0 || pos > this.usedSize) {
System.out.println("pos位置不合法");
return;
}
//从后往前挪元素
for (int i = this.usedSize; pos < i; i--) {
this.elem[i+1] = this.elem[i];
}
this.elem[pos] = data;
this.usedSize++;
}
// 打印顺序表
public void display() {
for (int i = 0; i < this.usedSize; i++) {
System.out.print(this.elem[i]+" ");
}
System.out.println();
}
// 判定是否包含某个元素
public boolean contains(int toFind) {
for (int i = 0; i < this.usedSize; i++) {
if(this.elem[i] == toFind) return true;
}
return false;
}
// 查找某个元素对应的位置
public int search(int toFind) {
for (int i = 0; i < this.usedSize; i++) {
if(this.elem[i] == toFind) return i;
}
return -1;
}
// 获取 pos 位置的元素
public int getPos(int pos) {
//判断合法性
if(pos < 0 || pos >= this.usedSize) {
System.out.println("pos位置不合法");
return -1;
}
return this.elem[pos];
}
// 给 pos 位置的元素设为 value
public void setPos(int pos, int value) {
//判断合法性
if(pos < 0 || pos >= this.usedSize) {
System.out.println("pos位置不合法");
return;
}
this.elem[pos] = value;
}
//删除第一次出现的关键字key
public void remove(int key) {
int ret = search(key);
if(ret == -1) {
System.out.println("关键字key不存在");
return;
}
for (int i = ret; i < this.usedSize-1; i++) {
this.elem[i] = this.elem[i+1];
}
this.usedSize--;
}
// 获取顺序表长度
public int size() {
return this.usedSize;
}
// 清空顺序表
public void clear() {
this.usedSize = 0;
}
}
三、顺序表的优点和缺点
1.顺序表的优点
- 可以通过一个下标，能够快速的找到当前的数据，时间复杂度为O(1)
2.顺序表的缺点
- 删除和插入数据的时候，都需要移动数据，时间复杂度为O(N)
- 每次扩容的时候，需要拷贝数组的内容。
- 每次都会浪费内存
增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。
总结
1.顺序表是逻辑上和物理上都连续
2.如果是给定下标的 查找 和 修改 使用的比较多，就使用顺序表。