Directorio de artículos
prefacio
En la sección anterior, aprendimos la ordenación rápida de cubos de clasificación de burbuja en el algoritmo de clasificación, por lo que el principal contenido de aprendizaje de esta sección es el conocimiento de la estructura de datos relevante de la lista vinculada de la pila de cola
1. Conocimiento básico de la estructura de datos (conocimiento de conexión)
Basado en el estudio de este libro, algunos novatos algorítmicos e incluso estudiantes de primaria están aprendiendo, por lo que me gustaría agregar algunos conocimientos básicos de estructura de datos para todos, para que todos puedan comprender mejor el conocimiento en esta sección.
1. ¿ Qué significa "primero en entrar, último en salir" en la pila?
La pila tiene dos operaciones principales para la gestión de datos:
- Empujar pila: La operación de inserción de la pila se llama empujar/empujar/empujar, y la pila se empuja desde la parte superior de la pila.
- Explosión: la operación de eliminación de la pila se denomina extracción y la pila se extrae desde la parte superior de la pila.
2. La definición de la pila
La pila sólo permite la operación de insertar y eliminar elementos en una sección fija. El extremo que realiza operaciones de inserción y eliminación de datos se denomina parte superior de la pila, y el extremo que no realiza operaciones se denomina parte inferior de la pila. Los elementos de la pila siguen el principio de último en entrar, primero en salir (LIFO - Last Primero en salir). Es decir, primero en entrar, último en salir, último en entrar, primero en salir.
3.
La metáfora de la imagen de la diferencia entre una pila y una cola es que una pila es como una bala, y el primero en entrar sale disparado al final, mientras que la cola es el interior de la cola, el primero que llega, primero servido.
Después de leer esto, si desea saber más sobre colas y pilas, puede leer mis dos blogs a continuación para aprender
[estructura de datos] explicar las colas en términos simples con mil palabras (código original adjunto | explicación súper detallada)
Dos, la cola
definición de cola
队列：Una tabla lineal especial que solo permite insertar operaciones de datos en un extremo y eliminar operaciones de datos en el otro extremo .
FIFO(First In First Out)En la cola: el final de la operación de inserción se llama cola de la cola Fuera de la cola: el final de la operación de eliminación se llama cabeza de la cola
El diagrama de la estructura de datos es el siguiente:
la cabeza de la cola (head) elimina datos, lo que se denomina "fuera de la cola" y la
cola de la cola (tail) inserta datos, lo que se denomina "entrada en la cola"
. Cuando no hay ningún elemento en la cola (cabeza == cola), se llama cola vacía
Tema Descripción
Al comienzo del nuevo semestre, Xiao Hum y Xiao Ha se sentaron en la misma mesa, y luego Xiao Hun le preguntó a Xiao Ha cuál era su número de QQ, pero Xiao Ha no le dio a otros su número de QQ fácilmente, así que dio una serie. de números misteriosos, pero los números son números regulares
La regla es borrar primero el primer número, luego poner el segundo número al final de la cadena, luego borrar el tercer número y poner el cuarto número al final...
Hasta que quede el último número, también se borrará el último número. Conectar los números eliminados juntos es el número QQ de Xiaoha. La cadena de números que Xiaoha cifró para él es "920430714", ¿cuál es el número QQ de Xiaoha?
ideas para resolver problemas
La operación de borrar un número al frente del equipo es head++
La operación de agregar un número al final del equipo es q[tail]=x , tail++
Ahora hay 9 números, después de poner 9 números en la cola, cara == 1, cola == 10, en este momento el número entre cara y cruz es el número "válido" en la cola actual
el código se muestra a continuación
//方法一：
#include<iostream>
using namespace std;
int main()
{
int q[102]={
0,6,3,1,7,5,8,9,2,4},head,tail;
//初始化队列
head=1;//指向第一个
tail=10;//指向最后一个的下一个
while(head<tail)//队列不为空
{
//打印队首
printf("%d ",q[head]);
head++;//队首出队
//先将新队首得数添加到队尾
q[tail]=q[head];
tail++;
//再将队首出队
head++;
}
return 0;
}
instancia de muestra
输入：6 3 1 7 5 8 9 2 4
输出：6 1 5 9 4 7 2 8 3
Encapsule los tres elementos básicos de la cola (una matriz y dos variables) en un tipo de estructura. De hecho, el primer método no debe usarse en la competencia de algoritmos.
//方法二
#include<iostream>
using namespace std;
struct queue
{
int data[100];
int head;
int tail;
};
int main()
{
struct queue q;
int i;
//初始化队列
q.head=1;
q.tail=1;
for(int i=1;i<=9;++i)
{
//依次向队列插入9个数
cin>>q.data[q.tail];
q.tail++;
}
while(q.head<q.tail)
{
//打印队首并将队首出队
cout<<q.data[q.head]<<" ";
q.head++;
q.data[q.tail]=q.data[q.head];
q.tail++;
q.head++;
}
return 0;
}
Tres, la pila
Pila último en entrar primero en salir, hay muchos ejemplos en la vida:
1. Para navegar por la página web y volver a una página web anterior, debe hacer clic en el botón Atrás paso a paso
2. Cargue la bala en el cargador, la última bala cargada es la primera que se dispara o la primera que se expulsa
3 Y, por ejemplo, en un balde pequeño, el diámetro del balde pequeño solo puede contener una pelota y poner las bolas 2, 1 y 3 en secuencia. Si desea sacar la bola 2, primero debe sacar la bola 3, luego sacar la bola 1, y finalmente Para sacar la bola No. 2 que se puso primero
El problema principal en esta sección de la pila es juzgar la cadena de palíndromo. De hecho, he escrito este tema cuando estaba aprendiendo lenguaje C. Niuke tiene este tema.
Ideas para resolver problemas:
divida la cadena en dos, establezca el punto medio como medio, empuje la cadena a la izquierda de la mitad en la pila y luego deje que las letras de la pila coincidan con los caracteres después de la mitad después de haber sido empujadas a la pila, y establezca Top , cada vez que la coincidencia sea exitosa Top–, finalmente verifique si Top es 0, si es 0, significa que es un palíndromo, de lo contrario no es un carácter palíndromo
Operación de apilamiento: s[++top] = a[i];
Obtenga la longitud de la cadena desde len hasta strlen(a), mid = len / 2 - 1;
el código se muestra a continuación:
#include<iostream>
#include<cstring>
using namespace std;
char a[110],s[110];
int len,mid,next,top;
int main()
{
cin.get(a,110);//读入字符串
len=strlen(a);//求字符串长度
mid=len/2-1;//求字符串的中点
//入栈操作
for(int i=0;i<=mid;++i)
{
s[++top]=a[i];
}
//判断字符串的长度是奇数还是偶数，并找出需要进行字符匹配的下标
if(len%2==0) next=mid+1;
else next=mid+2;
//开始匹配
for(int i=next;i<=len-1;++i)
{
if(a[i]!=s[top]) break;
top--;
}
if(top==0) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
instancia de muestra
输入：nihaooahin
输出：Yes
Expliquemos la idea de no usar la pila:
aritmética de doble puntero, apuntando respectivamente a los lados izquierdo y derecho de la cadena para ir uno hacia el otro, uno a uno haciendo coincidir, cuando los caracteres señalados por los dos punteros son diferentes, salida NO, cuando los dos punteros se encuentran o pasan entre sí, salida Sí
el código se muestra a continuación:
#include<iostream>
#include<cstring>
using namespace std;
char a[110];
int is_huiwen(int left,int right)
{
while(left<right)
{
if(a[left++]!=a[right--]) return 0;
else continue;
}
return 1;
}
int main()
{
cin.get(a,110);
int right=strlen(a)-1;
if(is_huiwen(0,right)) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
return 0;
}
4. Lista enlazada
Definición de lista enlazada
链表Es una estructura de almacenamiento 物理存储结构cada 非连续vez 非顺序más alta, y los elementos de datos se realizan 逻辑顺序a través 链表中的指针del orden de enlace .
Implementar lista enlazada
Use punteros y la función malloc de asignación de memoria dinámica para lograr
1. Para punteros
, vea el blog para más detalles: Lenguaje C—principiantes de punteros—resumen
2. La función malloc
1 malloc(sizeof(int))
es equivalente a malloc(4), se aplica para asignar un espacio de memoria de 4 bytes de la memoria
2 Ahora hemos solicitado con éxito un espacio de 4 bytes de la memoria para almacenar un entero, ¿cómo operar en este espacio?
Esto requiere un puntero para apuntar a este espacio, es decir, para almacenar la primera dirección de este espacio
. otro tipo de puntero, aquí necesitamos forzar la conversión a entero, por lo que es (int *)
int *p; //定义指针p
p = (int *)malloc(sizeof(int));
La función malloc() se aplica dinámicamente al espacio:
#include<iostream>
#include<cstdlib> //malloc()
using namespace std;
int main()
{
int *p; //定义指针p
//指针p获取动态分配的内存地址
p = (int *)malloc(sizeof(int));
*p = 10; //向p所指向的内存存入10
cout<<*p<<endl; //输出p指向内存中的值
return 0;
}
Cada nodo se compone de dos partes. La parte izquierda almacena valores específicos y la parte derecha almacena la dirección del siguiente nodo (llamado puntero sucesor). Aquí definimos un tipo de estructura para almacenar este nodo. Ver mi blog de estructura de datos [ data]
para detalles Estructura] 10,000 caracteres explican la lista de un solo enlace en términos simples (con código original | explicación súper detallada)
Problema: Crear una lista enlazada
#include<iostream>
#include<cstdlib> //malloc()
using namespace std;
struct node
{
int data;
struct node *next;
};
int main()
{
struct node *head, *p, *q, *t;
int i, n, a;
cin>>n;
head = NULL; //头指针初始为空
for(i = 1; i <= n; ++i) {
cin>>a;
//动态申请一个空间存放节点，临时指针p指向这个节点
p = (struct node *)malloc(sizeof(struct node));
p->data = a; //数据存储到数据域
p->next = NULL; //后继指针指向空
if(head == NULL)
head = p; //第一个节点让头指针指向
else
q->next = p; //否则上一节点后继指针指向当前节点
q = p; //上一节点指针指向当前节点
}
//输出链表中所有数
t = head;
while(t != NULL) {
cout<<t->data<<" ";
t = t->next; //继续下一节点
}
return 0;
}
Problema: insertar datos
#include<iostream>
#include<cstdlib> //malloc()
using namespace std;
//创建一个结构体表示节点
struct node
{
int data;
struct node *next;
};
int main()
{
struct node *head, *p, *q, *t; //p,q,t都是临时指针
int i, n, a;
cin>>n; //n个数
head = NULL; //头指针初始为空
for(i = 1; i <= n; ++i) {
cin>>a;
//动态申请空间存放一个节点，临时指针p指向该节点
p = (struct node *)malloc(sizeof(struct node));
p->data = a;
p->next = NULL; //当前节点下一节点为空
if(head == NULL)
head = p; //若为第一个创建的，头指针指向该节点
else
q->next = p; //上一节点后继指针指向当前节点
q = p; //指针q指向当前节点
}
cin>>a; //待插入的数
t = head; //从链表头部开始遍历
while(t != NULL) {
if(t->next == NULL || t->next->data > a) {
p = (struct node *)malloc(sizeof(struct node));
p->data = a;
//新增节点后继指针指向当前节点后继指针所指向的节点
p->next = t->next;
t->next = p; //当前节点后继指针指向新增节点
break; //插入完退出循环
}
t = t->next; //继续下一节点
}
//输出链表所有数
t= head;
while(t != NULL) {
cout<<t->data<<" ";
t = t->next; //继续下一节点
}
return 0;
}
Resumir
Vaya aquí primero y continúe agregando más tarde