Mi informacion de contacto
Correo[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Al igual que escribir algunas interfaces funcionales para listas con enlaces simples, primero escribamos algunas interfaces para listas con enlaces dobles para familiarizarnos con su marco principal:
#incluir<stdio.h>
#incluir<stdlib.h>
tipo de definición int LDataType;
// El nodo de la lista enlazada circular de dos direcciones
typedef estructura ListaNodo{
LDataType _datos;
//Apunta a la posición inicial del siguiente nodo
estructura ListNode* _next;
//Apunta a la posición inicial del nodo anterior
estructura LIst* _prev;
}NodoLista;
//Lista enlazada circular con encabezados bidireccionales
typedef estructura Lista{
estructura ListaNodo* _cabeza;
}Lista;
estructura ListNode*createListNode(LDataType val){
struct ListNode* nodo = (struct ListNode*)malloc(sizeof(struct ListNode));
nodo->_data = val;
nodo->_siguiente = NULL;
nodo->_prev = NULL;
}
vacío ListInit(Lista* lst){
//Lista enlazada vacía
lst->_head = crearListNode(0);
lst->_cabeza->_siguiente = lst->_cabeza->_anterior = lst->_cabeza;
}
//Inserción de cola O(1) //Insertar datos delante del encabezado ListInsert(lst, lst->_head, val);
vacío ListpushBack(Lista* lst, LDataType val){
si (lst == NULL){
devolver;
estructura ListNode* último = lst->_head->_prev;
estructura ListNode* newNode = crearListNode(val);
//_head ... último nuevoNodo
último->_siguiente = nuevoNodo;
nuevoNodo->_prev = último;
nuevoNodo->_siguiente = lst->_head;
lst->_head->_prev = nuevoNodo;
}
}
// Eliminación de cola: // Elimina el nodo anterior del encabezado ListErase(lst, lst->_head->_prev);
vacío ListPopBack(Lista* lst){
si (lst == NULL)
devolver;
//Determinar si la lista vinculada está vacía
si (lst->_cabeza->_siguiente == lst->_cabeza)
devolver;
estructura ListNode* último = lst->_head->_prev;
estructura ListNode* prev = last->_prev;
libre(ultimo);
lst->_head->_prev = anterior;
anterior->_siguiente = lst->_head;
}
void imprimirLista(Lista* lst){
estructura ListNode* cur = lst->_head->_next;
mientras (cur != lst->_head){
printf("%d", cur->_data);
cur = cur->_siguiente;
}
printf("n");
}
//Inserción de encabezado//ListInsert(lst,lst->_head->_next,val);
vacío ListPushFront(Lista* lst, LDataType val){
si (lst == NULL)
devolver;
estructura ListNode* siguiente = lst->_head->_next;
estructura ListNode* newNode = crearListNode(val);
//_cabeza, nuevoNodo, siguiente
lst->_head->_next = nuevoNodo;
nuevoNodo->_prev = lst->_head;
nuevoNodo->_siguiente = siguiente;
siguiente->_prev = nuevoNodo;
}
//eliminar encabezado//ListErase(lst,lst->_head->_next);
vacío ListPopFront(Lista* lst){
si (lst == NULL || lst->_head == lst->_head)
devolver;
estructura ListNode* siguiente = lst->_head->_next;
estructura ListNode* nextnext = siguiente->_siguiente;
siguientesiguiente->_anterior = siguiente->_siguiente;
lst->_head->_next = siguientesiguiente;
libre(siguiente);
}
void ListErase(Lista* lst, estructura ListNode* nodo){
//No se puede eliminar el nodo principal
si (lst == NULL || lst->_head == nodo)
devolver;
//prev, nodo, siguiente
struct ListNode* prev = nodo->_prev;
struct ListNode* next = nodo->_siguiente;
prev->_next = siguiente;
siguiente->_prev = prev;
libre(nodo);
}
vacío ListInsert(List* lst, struct ListNode* nodo, LDataType val){
si (lst == NULL)
devolver;
struct ListNode* prev = nodo->_prev;
estructura ListNode* newNode = crearListNode(val);
//prev nuevoNodo nodo
prev->_next = nuevoNodo;
nuevoNodo->_prev = prev;
nuevoNodo->_siguiente = nodo;
nodo->_prev = nuevoNodo;
}
//destruir
ListaDestoty(Lista* lst){
si (lst){
si (lst->_head){
estructura ListNode* cur = lst->_head->_next;
mientras (cur != lst->_head){
struct ListNode* siguiente = cortar->_siguiente;
libre(cur);
cur = siguiente;
}
libre(lst->_head);
}
}
}
prueba nula(){
Lista lst;
ListaInit(&lst);
ListaPushFront(&lst, 5);
imprimirLista(&lst);
ListaPushFront(&lst, 1);
imprimirLista(&lst);
ListaPushFront(&lst, 2);
imprimirLista(&lst);
ListaPushFront(&lst, 3);
imprimirLista(&lst);
ListaPushFront(&lst, 4);
imprimirLista(&lst);
ListaPopFront(&lst);
imprimirLista(&lst);
ListaPopFront(&lst);
imprimirLista(&lst);
ListaPopFront(&lst);
imprimirLista(&lst);
/*ListPopBack(&lst);
imprimirLista(&lst);
ListaPopBack(&lst);
imprimirLista(&lst);
ListaPopBack(&lst);
imprimirLista(&lst);
ListaPopBack(&lst);
imprimirLista(&lst);*/
}
int principal(){
prueba();
sistema("pausa");
devuelve 0;
}
La diferencia y conexión entre lista de secuencia y lista enlazada:
Ventajas y desventajas de la tabla de secuencia: Excelente: el espacio es continuo, admite acceso aleatorio, tiene una alta utilización del espacio y no es probable que cause fragmentación de la memoria, y tiene una alta eficiencia de inserción y eliminación de colas.
Desventajas: 1. La complejidad temporal de insertar y eliminar la parte intermedia o frontal es O (N) 2. El costo de expansión de capacidad es relativamente alto: solicite la liberación de la copia
Ventajas y desventajas de las listas enlazadas (listas enlazadas aleatorias bidireccionales dirigidas)
Ventajas: 1. La complejidad temporal de insertar y eliminar en cualquier posición es O (1) 2. No hay problema de expansión de capacidad, insertar uno abre un espacio y la eficiencia de insertar y eliminar en cualquier posición es alta
Desventajas: se almacena en unidades de nodos, no admite el acceso aleatorio y la baja utilización del espacio puede provocar fácilmente la fragmentación de la memoria.
pilas y colas
Pila: una lista lineal especial que solo permite la inserción y eliminación de elementos en un extremo. El extremo donde se realizan las operaciones de inserción y eliminación de datos se denomina parte superior de la pila y el otro extremo se denomina parte inferior de la pila. en la pila sigue el principio LIFO (último en entrar, primero en salir)
Empujar la pila: la operación de inserción de la pila se llama empujar/empujar/empujar, y los datos insertados están en la parte superior de la pila.
Pop: la operación de eliminación de la pila se llama popping, y los datos que se extraen también están en la parte superior de la pila.
Implementación de la operación push push--->almacenar elementos desde la parte superior de la pila
Tabla de secuencia: puede considerarse como una operación de inserción de cola.
Lista enlazada: (lista enlazada circular con encabezado bidireccional) el encabezado de la lista se considera la parte superior de la pila, que es la inserción del encabezado, y la cola de la lista se considera la parte superior de la pila, que es la inserción de la cola.
Operación emergente pop--->eliminar elementos de la parte superior de la pila
Tabla de secuencia: el final de la tabla se considera la parte superior de la pila y la operación de eliminación final.
Lista enlazada: (lista enlazada circular con encabezado bidireccional) el encabezado de la lista se considera la parte superior de la pila, que es la eliminación del encabezado, y la cola de la lista se considera la parte superior de la pila, que es la eliminación de cola.
#incluir<stdio.h>
#incluir<stdlib.h>
tipo de definición int STDataType;
//La tabla de secuencia implementa una pila
typedef estructura pila{
STDataType* _datos;
int _tamaño;
int _capacidad;
}pila;
vacío stackInit(pila* st){
si (st == NULL)
devolver;
st->_data = NULL;
st->_tamaño = st->_capacidad = 0;
}
anular comprobaciónCapacidad(pila* st){
si (st->_tamaño == st->_capacidad){
int nuevaCapacidad = st->_capacidad == 0 ? 1 : 2 * st->_capacidad;
st->_data = (STDataType*)realloc(st->_data, tamaño de(STDataType)* nuevaCapacidad);
st->_capacidad = nuevaCapacidad;
}
}
// Empujar para apilar
vacío pilaPush(pila* st, STDataType val){
si (st == NULL)
devolver;
comprobarCapacidad(st);
//inserción de cola
st->_datos[st->_tamaño++] = val;
}
//estallido
void pilaPop(pila* st){
si (st == NULL)
devolver;
si (st->_tamaño > 0)
st->_tamaño--;
}
STDataType pilaTop(pila* st){
devuelve st->_data[st->_size - 1];
}
int tamañopila(pila* st){
si (st == NULL)
devuelve 0;
retorna st->_size;
}
prueba nula(){
pila st;
pilaInit(&st);
pilaPush(&st, 1);
pilaPush(&st, 2);
pilaPush(&st, 3);
pilaPush(&st, 4);
para (int i = 0; i < 4; ++i){
printg("%d", pilaTop(&st));
pilaPop(&st);
}
printf("n");
}
int principal(){
prueba();
sistema("pausa");
devuelve 0;
}
Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.
Correo[email protected]