Al revisar preguntas y realizar entrevistas, siempre encontrará preguntas como listas vinculadas. Echemos un vistazo a las preguntas sobre Leetcode:
1. ¿Qué es una lista vinculada?
Para representar cada elemento de datos ai a_iayoEn lugar de los datos del sucesor directo ai + 1 a_ {i + 1}ai + 1La relación lógica entre, para datos ai a_iayoEn otras palabras, además de almacenar su propia información, también necesita almacenar una indicación de la información de su sucesor (es decir, la ubicación de almacenamiento del sucesor inmediato). Llamamos dominio de datos al dominio que almacena los datos de los elementos , y el dominio que se almacena en la posición del sucesor inmediato se denomina dominio de puntero . La información almacenada en el campo del puntero se denomina puntero o cadena. Este mensaje de dos partes que consta del elemento de datos ai a_iayoLa imagen de almacenamiento se llama nodo .
Para la lista vinculada, el nodo principal es opcional, aparecerá antes del primer nodo de la lista vinculada individualmente y agregará un nuevo nodo para proporcionar información adicional (como la longitud) de la lista vinculada.
Una lista vinculada no puede tener un nodo principal, pero debe tener un puntero principal, por lo que el nombre de una lista vinculada generalmente se representa mediante un puntero principal. El papel del nodo principal:
- Al eliminar e insertar la lista vinculada, la operación del primer nodo es más conveniente
- Procesamiento unificado de listas vacías y no vacías
Para obtener una explicación específica, consulte https://blog.csdn.net/snow_7/article/details/106919353
De acuerdo con el dominio de puntero, solo hay una llamada lista enlazada individualmente. Esta sección solo presenta listas enlazadas individualmente. Más adelante presentaremos listas enlazadas circulares y listas enlazadas doblemente.
En segundo lugar, la estructura del nodo
Usaremos punteros para implementar esta estructura, que contiene al menos dos partes, el campo de puntero y el campo de datos.
typedef struct Node{
int data;
struct Node* next;
}Node;
typedef struct Node* pNode;//指向一个结点的指针
¡Muy importante! ! ! ! Para una lista vinculada sin nodos principales adicionales, el puntero principal apunta al primer nodo de la lista vinculada; si es una lista vinculada con nodos principales adicionales, el puntero principal apunta a este nodo principal adicional. Parece que no hay un nodo principal adicional al escribir la pregunta, y si el nodo principal apunta a vacío, entonces la longitud de la lista vinculada es 0, es decir, la lista vinculada vacía; si el nodo principal -> siguiente está vacío , la longitud de la lista vinculada es 1. El nodo principal no es igual al primer nodo, es el nodo anterior al primero.
Tres, valor
//pHead在这里是一个指向头结点或者第一个结点
bool get_index_element(pNode pHead, int i, int* value)
{
int j = 1;//用于标识当前检查的结点号
pNode pCurNode = pHead->next;//j=1,cur指向结点1
//进入循环的条件：没有达到链表最后结点或者还没检查到指定序号结点或给了一个比1还要小的检查序号
while (pCurNode &&j<i)
{
//更新序号和待检查结点指针pCurNode
j++;
pCurNode = pCurNode->next;
}
//若到达最后了仍然没有找指定序号结点，那么说明长度不够，返回false
//或者是用户给了一个不正确的序号参数(i<1)
if (!pCurNode && i < j)
{
return false;
}
*value= pCurNode->data;
return true;
}
PD: si el puntero cur es un puntero nulo, se convierte implícitamente en falso, de lo contrario es verdadero
Cuarto, inserte delante del elemento
Antes o después de que el elemento seleccionado se inserte de acuerdo con el nuevo elemento
bool insert_index_element(pNode * pHead,int i,int value)
{
int j = 1;
pNode pCurNode = pHead->next;
while (pCurNode || j < i)
{
pCurNode = pCurNode->next;
j++;
}
if (!pCurNode && i < j)
{
return false;
}
pNode pNewNode = (pNode)malloc(sizeof(Node));
pNewNode->data = value;
pNewNode->next = pCurNode->next;
pCurNode->next = pNewNode;
return true;
}
Cinco, eliminar
bool delete_index_element(pNode pHead, int i, int *value)
{
int j = 1;
pNode pCurNode = pHead;
while (!pCurNode->next || j < i)
{
pCurNode = pCurNode->next;
j++;
}
if (!pCurNode->next || i < j)
{
return false;
}
*value = pCurNode->next->data;
pNode q=pCurNode->next;//必要操作，防止下一步pCurNode->next丢失掉需要释放空间的结点
pCurNode->next = pCurNode->next->next;
free(pCurNode->next);
return true;
}
Seis, crea la lista completa vinculada
La creación de una lista vinculada se puede dividir en dos tipos según el método de inserción: preinserción y posinserción.
Inserción de cola
//尾部插入法
void create_random_list(pNode* pHead, int n)
{
srand(time(0));//初始化种子
*pHead = (pNode)malloc(sizeof(Node));//创建头结点
pNode pFinalNode = *pHead;
pNode pNewNode = nullptr;
for (int i = 0; i < n; i++)
{
pNewNode = (pNode)malloc(sizeof(Node));
pNewNode->data = rand() % 100 + 1;
cout << pNewNode->data << endl;
pFinalNode->next = pNewNode;
pFinalNode = pNewNode;
}
pFinalNode->next = nullptr;
}
//头部插入法
void front_create_list(pNode* pHead, int n)
{
srand(time(0));//初始化种子
*pHead = (pNode)malloc(sizeof(Node));//创建头结点
pNode pNewNode = nullptr;
for (int i = 0; i < n; i++)
{
pNewNode = (pNode)malloc(sizeof(Node));
pNewNode->data = rand() % 100 + 1;
cout << pNewNode->data << endl;
pNewNode->next = (*pHead)->next;
(*pHead)->next = pNewNode;
}
pNewNode->next = nullptr;
}
Aquí, pasamos el puntero al nodo , porque cambió los puntos del puntero principal a, si no participa en la creación y eliminación del nodo principal, no se puede pasar un puntero a un puntero .
Siete, elimine toda la lista vinculada
void clear_list(pNode pHead)
{
pNode pCurNode= pHead->next;
pNode pNextNode = pCurNode;
while (pCurNode)//指针域不为空
{
pNextNode = pCurNode->next;
free(pCurNode);
pCurNode = pNextNode;
}
pHead->next = nullptr;
}
[1] https://blog.csdn.net/snow_7/article/details/106919353