Java: implementar una tabla de secuencia
1. La tabla de secuencia es una estructura lineal en la que una sección de unidades de almacenamiento con direcciones físicas continuas almacena elementos de datos en secuencia. Generalmente, se utiliza almacenamiento de arreglo. Completa la adición, eliminación, verificación y modificación de datos en la matriz.
La tabla de secuencia generalmente se puede dividir en:
tabla de secuencia estática: use almacenamiento de matriz de longitud fija.
Tabla de secuencia dinámica: utilice almacenamiento de matriz desarrollado dinámicamente .
La tabla de secuencia estática es adecuada para escenarios en los que se sabe cuántos datos se deben almacenar.
La matriz de longitud fija de la tabla de secuencia estática hace que N sea más grande, el espacio se desperdicia y menos no es suficiente.
Por el contrario, la tabla de secuencia dinámica es más flexible, de acuerdo con la necesidad de asignar dinámicamente el tamaño del espacio.
2. Implementar una tabla de secuencia
1. Primero defina los atributos y métodos de construcción de la
tabla de secuencia : la capa inferior de la tabla de secuencia es una matriz, por lo que se requiere una matriz y un atributo que defina los números efectivos en la matriz, y se proporciona un método de construcción. Los parámetros se puede configurar en el método de construcción.
public class MyArrayList {
//顺序表所需要的属性；
public int[] elem;//引用类型默认为空
public int usedSize;//不给初始化，默认为0
//提供构造方法
public MyArrayList() {
//无参数的构造方法
this.elem = new int[6];
}
public MyArrayList(int capacity) {
//有参数的构造方法
this.elem = new int[capacity];
}
2. Realice algunas operaciones:
1. Agregue nuevos elementos
// 在 pos 位置新增元素
public void add(int pos, int data) {
if(isFull()){
//System.out.println("顺序表为满");
resize();
//return;
}
if(pos <0 || pos >this.usedSize){
System.out.println("pos位置不合法");
}
//代码走这说明满足条件，插入
for (int i =usedSize-1; i >= pos ; i--) {
this.elem[i+1] = this.elem[i];//数据从后挪；
}
this.elem[pos] = data;
usedSize++;//重新记录有效数字
}
public void add2(int data){
if(isFull()){
//System.out.println("顺序表为满");
resize();
//return;
}
this.elem[usedSize]=data;
usedSize++;//重新记录有效数字
}
2. Si contiene un elemento
// 判定是否包含某个元素
public boolean contains(int toFind) {
for (int i = 0; i <usedSize ; i++) {
if(this.elem[i] == toFind ){
return true;
}
}
return false;
}
3. Encuentra la posición correspondiente a un elemento.
// 查找某个元素对应的位置
public int search(int toFind) {
for (int i = 0; i <usedSize ; i++) {
if(this.elem[i] == toFind ){
return i;
}
}
return -1;
}
4. Obtener el elemento en la posición pos.
// 获取 pos 位置的元素
public int getPos(int pos) {
if(pos<0 || pos>=usedSize){
return -1;
}
for (int i = 0; i <usedSize ; i++) {
if(i==pos){
return this.elem[i];
}
}
return -1;
}
5. Coloque el elemento en la posición pos como valor.
// 给 pos 位置的元素设为 value
public void setPos(int pos, int value) {
//判断pos的值是否合法
if( pos<0 || pos>=usedSize ){
return;
}
//找到pos;
for (int i = 0; i <usedSize ; i++) {
if(i==pos){
this.elem[i]=value;
}
}
}
6. Tabla de secuencia de impresión
// 打印顺序表
public void display() {
for (int i = 0; i < usedSize; i++) {
System.out.print(this.elem[i]+" ");
}
System.out.println();
}
7. Determine si la matriz está llena.
public boolean isFull(){
//判断数组是否为满
if(this.usedSize == elem.length){
return true;
}
return false;
}
8. Operación de expansión
public void resize(){
//扩容操作
this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
}
9. Elimine la clave de palabra clave que aparece por primera vez.
// 删除第一次出现的关键字key
public void remove(int key) {
//1、查找是否有key index
int index = search(key);
if(index == -1) {
System.out.println("没有找到");
return;
}
//找到之后i = index； i < usdSize-1
for(int i = index;i < this.usedSize-1;i++) {
this.elem[i] = this.elem[i+1];
}
//3、this.usedSize--;
this.usedSize--;//长度减小
}
10. Obtenga la longitud de la tabla de secuencia
// 获取顺序表长度
public int size() {
return usedSize;
}
11. Limpiar la tabla de secuencia
// 清空顺序表
public void clear() {
this.usedSize = 0;
}
Código de prueba:
public class TestDemo {
public static void main(String[] args) {
MyArrayList myArrayList =new MyArrayList();//有参数
//myArrayList.add3(123);
//myArrayList.add3(124);
//MyArrayList myArrayList1 = new MyArrayList(20);//无参数
myArrayList.add(0,12);
myArrayList.add(1,22);
myArrayList.add(2,32);
myArrayList.add(3,42);
myArrayList.add2(123);
myArrayList.add2(124);
myArrayList.display();
System.out.println("===========");
int ret = myArrayList.usedSize;
System.out.println(ret);
System.out.println("========");
System.out.println(myArrayList.contains(12));
System.out.println("==========");
System.out.println(myArrayList.search(12));
System.out.println("==========");
myArrayList.remove(32);
myArrayList.display();
System.out.println("=========");
System.out.println(myArrayList.getPos(2));
System.out.println("========");
myArrayList.setPos(0,10);
myArrayList.display();
}
}
Captura de pantalla del resultado:
Desventajas de la tabla de secuencia:
- Inserción y eliminación en el medio / encabezado de la tabla de secuencia, la complejidad del tiempo es O (N)
- Para aumentar la capacidad, debe solicitar un nuevo espacio, copiar datos y liberar espacio antiguo. Habrá mucho consumo.
- El aumento de capacidad es generalmente un aumento doble, y es probable que se pierda una cierta cantidad de espacio. Por ejemplo, la capacidad actual es 100, y la capacidad aumenta a 200 cuando está llena. Continuamos insertando 5 datos, y no hay datos para insertar más tarde, entonces se desperdician 95 espacios de datos.