Estructura de datos y algoritmo (tabla lineal)
Mesa lineal (estructura de almacenamiento lineal)
Consiste en encadenar los datos y almacenarlos en la dirección física. Los datos con una relación "uno a uno" se almacenan "linealmente" en el espacio físico. Esta estructura de almacenamiento se denomina estructura de almacenamiento lineal (denominada tabla lineal).
Estructura de almacenamiento secuencial
Como se muestra en la Figura 3a, los datos se almacenan en direcciones físicas consecutivas. Cuando la tabla de secuencia almacena datos, almacena todos los datos en direcciones consecutivas sin dejar espacios entre ellos.
Inicialización de la tabla de secuencia
Antes de usar la tabla de secuencia, debe solicitar espacio y también registrar la capacidad de almacenamiento solicitada y el número de elementos de datos en la tabla.
- Definir una tabla lineal y colocar elementos en ella.
#include <stdio.h>
#include <stdlib.h>
typedef struct Table{
int * head;
int length;
int size;
}table;
table initTable(){
table t;
t.head=(int*)malloc(5*sizeof(int));
if(!t.head){
printf("初始化失败");
exit(0);
}else{
printf("初始化成功！");
}
t.length=0;
t.size=5;
return t;
}
int main(int argc, char *argv[]) {
table t=initTable();
printf("表的大小为%d",t.length);
int i;
for(i=0;i<5;i++){
t.head[i]=i;
t.length++;
}
for(i=0;i<t.size;i++){
printf("\n");
printf("%d",t.head[i]);
}
return 0;
}
Elemento de inserción de tabla de secuencia
- Insertar en el encabezado
- Insertar al final de la mesa
- En el medio
Para insertar un elemento, realice dos operaciones: mueva el elemento en la posición a ser insertado y los siguientes elementos como un todo hacia atrás, y agregue el elemento a la posición vacía.
// 在指定位置插入元素
table addElement(table t,int element,int pos){
// 插在表尾部
if(pos==t.length){
// 重新申请大小
t.head=(int*)realloc(t.head,(t.size+1)*sizeof(int));
if(!t.head){
printf("扩容失败！");
return t;
}
t.size+=1;
}
if(pos>t.size+1 || pos<1){
printf("插入位置错误");
exit(0);
}
// 将插入位置以及之后的元素向后移动
int i;
for(i=t.length-1;i>=pos-1;i--){
t.head[i+1]=t.head[i];
}
// 将元素放到空的位置
t.head[pos-1]=element;
t.length++;
return t;
}
Elemento de eliminación de tabla de secuencia
Simplemente mueva el elemento después de la posición de eliminación especificada hacia adelante en uno para eliminar la tabla lineal especificada como valor.
table delTable(table t, int add) {
int i;
if (add > t.length || add < 1) {
printf("被删除元素的位置有误");
exit(0);
}
//删除操作
for (i = add; i < t.length; i++) {
t.head[i - 1] = t.head[i];
}
t.length--;
return t;
}
Encontrar elemento
-
Encuentra el elemento objetivo;
-
Modifique el valor del elemento directamente;
//更改函数，其中，elem为要更改的元素，newElem为新的数据元素
table amendTable(table t, int elem, int newElem) {
int add = selectTable(t, elem);
t.head[add - 1] = newElem;//由于返回的是元素在顺序表中的位置，所以-1就是该元素在数组中的下标
return t;
}
Estructura de almacenamiento en cadena
Como se muestra en la Figura 3b, los datos numéricos se almacenan en direcciones físicas, pero el orden de los datos permanece sin cambios y el orden lógico entre los datos se mantiene a través de una línea.
Características del almacenamiento en cadena
Para almacenar los elementos de datos se utiliza un grupo de unidades de almacenamiento arbitrarias, que pueden ser continuas o discontinuas.
Lista enlazada
El concepto de listas enlazadas
- Dominio de datos: el dominio que almacena la información del elemento de datos se denomina dominio de datos.
- Campo de puntero: el campo que almacena la posición del sucesor inmediato se denomina campo de puntero.
- n nodos están vinculados a una lista vinculada, que es la estructura de almacenamiento en cadena de la lista lineal
Lista única
Cada nodo de la lista enlazada contiene solo un campo de puntero, la información almacenada en el campo de puntero se llama cadena y cada nodo de la cadena tiene solo uno. La ubicación de almacenamiento del primer nodo en la lista vinculada se denomina puntero principal. Si la lista vinculada tiene un nodo principal, el puntero principal es un puntero al campo de datos del nodo principal.
Definición de nodo
// 定义链表
typedef struct Node{
// 数据域
Item item;
// 指向后继节点的指针
struct Node *next;
}Node,*List;
Estructura de datos
/*数据域的数据结构体*/
typedef struct Contet{
int id;
char name[20];
}Item;
Inicializar la lista vinculada
// 初始化一个链表
List init(){
// 定义头节点
List head=(List)malloc(sizeof(Node));
if(!head){
printf("分配内存空间失败！");
return 0;
}else{
printf("内存分配成功链表创建！");
// 指针域为空
head->next=NULL;
return head;
}
}
Agregar datos a la lista vinculada
// 增加数据
void insert(List head){
// 定义新的节点对象
Item item;
printf("输入编号：");
scanf("%d",&item.id);
printf("输入姓名：");
scanf("%s",&item.name);
// 清空缓冲区
getchar();
List p=(List)malloc(sizeof(Node));
p->item=item;
p->next=head->next;
head->next=p;
}
Eliminar datos de la lista vinculada
#include <stdio.h>
#include <stdlib.h>
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
/*数据域的数据结构体*/
typedef struct Contet{
int id;
char name[20];
}Item;
// 定义链表
typedef struct Node{
// 数据域
Item item;
// 指向后继节点的指针
struct Node *next;
}Node,*List;
// 初始化一个链表
List init(){
// 定义头节点
List head=(List)malloc(sizeof(Node));
if(!head){
printf("分配内存空间失败！");
return 0;
}else{
printf("内存分配成功链表创建！");
printf("\n");
// 指针域为空
head->next=NULL;
return head;
}
}
// 增加数据
void insert(List head){
// 定义新的节点对象
Item item;
printf("输入编号：");
scanf("%d",&item.id);
printf("输入姓名：");
scanf("%s",&item.name);
// 清空缓冲区
getchar();
List p=(List)malloc(sizeof(Node));
p->item=item;
p->next=head->next;
head->next=p;
}
int main(int argc, char *argv[]) {
// 初始化链表
List head=init();
int n;
printf("输入你想录入数据的个数：");
scanf("%d",&n);
int i;
for(i=0;i<n;i++){
insert(head);
}
Item *p;
p=head->next;
printf("当前人编号：%d",p->id);
printf("当前人姓名：%s",p->name);
return 0;
}
Formación
En java, cuando se crea una matriz, una memoria contigua se divide en la memoria, y luego, cuando ingresan datos, los datos se almacenan en esta memoria contigua en orden. Cuando necesite leer los datos en la matriz, debe proporcionar el índice en la matriz, y luego la matriz extrae los datos de la memoria de acuerdo con el índice y los devuelve al programa de lectura. En Java, no todos los datos se pueden almacenar en una matriz, solo los datos del mismo tipo se pueden almacenar juntos en una matriz.
Caracteristicas
- El orden de almacenamiento se almacena en orden y la memoria para almacenar datos también es continua.
- Direccionar y leer datos es más fácil, pero la inserción y eliminación son más difíciles.
solicitud
ArrayList de matriz dinámica
- ArratList es equivalente a una matriz dinámica y admite la expansión.
- Cuando la matriz está definida, debido a que necesita asignar espacio de memoria contiguo, su tamaño debe especificarse de antemano. Cuando los datos almacenados son más grandes que su tamaño, debemos asignar un espacio mayor, copiar el original e insertar el nuevo Elementos.
- En ArrayList, cuando el espacio no es suficiente, se expandirá automáticamente a 1,5 veces el tamaño original.
Matriz estática
- Hay dos sintaxis para definir matrices en Java:
tipo nombreArray [],
tipo [] nombreArray;
cola
La cola es una estructura de datos de primero en entrar, primero en salir, las matrices y las listas enlazadas también pueden generar colas. Cuando los datos ingresan a la cola, también ingresan primero, luego ingresan abajo, luego ingresan arriba, pero al salir de la cola, salen primero de abajo, luego los datos de arriba, y la cola que ingresa al último, y luego sale al final.
@Test
public void test(){
Queue<Integer> queue=new LinkedList<>();
queue.offer(1);
queue.offer(2);
queue.offer(3);
queue.offer(4);
queue.offer(5);
queue.offer(6);
queue.forEach(System.out::println);
}
Cola de bloqueo
Cola concurrente
Apilar
La pila es una estructura de datos de primero en entrar, último en salir, y tanto las matrices como las listas enlazadas pueden generar pilas. Cuando los datos ingresan a la pila, se enviarán al final de la pila de acuerdo con las reglas, y los datos ingresados nuevamente se colocarán encima de los primeros datos, y así sucesivamente. Al obtener los datos de la pila, los datos principales se obtendrán primero, por lo que son los primeros en entrar, el último en salir.
@Test
public void test1(){
Stack<Integer> stack=new Stack<>();
stack.push(1);
stack.push(2);
stack.push(4);
stack.forEach(System.out::println);
}
. . . . . . Continuará