Lista enlazada (1) Operación detallada de lista enlazada única

1. ¿Qué es una lista enlazada?

La lista enlazada es una estructura de almacenamiento no secuencial y no secuencial en la estructura de almacenamiento físico.El orden lógico de los elementos de datos se realiza a través del orden de enlace de los punteros en la lista enlazada.

Estructura lógica:

Estructura física:

• La estructura de la cadena es lógicamente continua, pero no necesariamente físicamente continua.
• El nodo es el espacio aplicado del montón, que se asigna según la estrategia, y puede ser continuo o discontinuo

En segundo lugar, la clasificación de las listas enlazadas

de acuerdo aLista de enlaces simples y dobles,si hay una cabeza,Ya sea para andar en bicicleta, la lista enlazada se puede dividir enocho

1. Unidireccional o bidireccional

2. Liderar o no liderar

3. Andar en bicicleta o no andar en bicicleta

3. Implementación de lista enlazada no circular unidireccional sin cabeza

Diseño de estructura de código:

• SList.h: almacena la estructura de la lista enlazada y los archivos de encabezado requeridos, declaraciones de funciones, etc.
• SList.c: implementación concreta de varias funciones de operación

SList.h

#pragma once
#include <stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int SLTDateType;
typedef struct SListNode
{
    
    
	SLTDateType data;
	struct SListNode* next;
}SListNode;

// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);

SList.c

#include "SList.h"

Aplicar dinámicamente para un nodo

SListNode* BuySListNode(SLTDateType x)
{
    
    
	SListNode* newNode = (SListNode*)malloc(sizeof(SListNode));
	if (newNode == NULL)
	{
    
    
		perror("malloc fail");
		exit(-1);
	}
	newNode->data = x;
	newNode->next = NULL;

	return newNode;
}

Impresión de listas enlazadas individualmente

void SListPrint(SListNode* plist)
{
    
    
	SListNode* cur = plist;
	while (cur != NULL)
	{
    
    
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}

Enchufe de cola de lista enlazada única

void SListPushBack(SListNode** pplist, SLTDateType x)
{
    
    
	//pplist不能为空
	assert(pplist);
	//创建要插入的节点
	SListNode* newNode = BuySListNode(x);
	//链表没有节点时
	if (*pplist == NULL)
	{
    
    
		*pplist = newNode;
	}
	//链表有节点时
	else
	{
    
    
		SListNode* cur = *pplist;
		//找到链表的最后一个节点
		while (cur->next != NULL)
		{
    
    
			cur = cur->next;
		}
		cur->next = newNode;
	}
}

enchufe de cadena simple

void SListPushFront(SListNode** pplist, SLTDateType x)
{
    
    
	//pplist不能为空
	assert(pplist);
	SListNode* newNode = BuySListNode(x);
	newNode->next = *pplist;
	*pplist = newNode;
}

Eliminación de cola de lista enlazada individualmente

void SListPopBack(SListNode** pplist)
{
    
    
	assert(pplist);
	//检查链表是否为空
	assert(*pplist);

	//链表只有一个节点
	if ((*pplist)->next == NULL)
	{
    
    
		free(*pplist);
		*pplist = NULL;
	}
	else
	{
    
    
		SListNode* cur = *pplist;
		//找到倒数第二个节点
		while (cur->next->next != NULL)
		{
    
    
			cur = cur->next;
		}
		free(cur->next);
		cur->next = NULL;
	}
}

eliminación de encabezado de cadena única

void SListPopFront(SListNode** pplist)
{
    
    
	assert(pplist);
	//检查链表是否为空
	assert(*pplist);

	SListNode* cur = *pplist;
	*pplist = cur->next;
	free(cur);
}

Búsqueda de lista enlazada individualmente

SListNode* SListFind(SListNode* plist, SLTDateType x)
{
    
    
	SListNode* cur = plist;

	while (cur != NULL)
	{
    
    
		if (cur->data == x)
		{
    
    
			return cur;
		}
		cur = cur->next;
	}
	return cur;
}

Insertar antes de la posición pos.

void SLTInsert(SListNode** pplist, SListNode* pos, SLTDateType x)
{
    
    
	assert(pplist);
	assert(pos);

	if (pos == *pplist)
	{
    
    
		//在第一个节点前插入即头插
		SLTPushFront(pplist, x);
	}
	else
	{
    
    
		SListNode* prev = *pplist;
		while (prev->next != pos)
		{
    
    
			prev = prev->next;
		}

		SListNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}
}

La lista enlazada individualmente inserta x después de la posición pos.

void SListInsertAfter(SListNode* pos, SLTDateType x)
{
    
    
	assert(pos);

	SListNode* newNode = BuySListNode(x);
	newNode->next = pos->next;
	pos->next = newNode;
}

eliminar posición pos.

void SLTErase(SListNode** pplist, SListNode* pos)
{
    
    
	assert(pplist);
	assert(pos);

	if (pos == *pplist)
	{
    
    
		//删除第一个节点即头删
		SLTPopFront(pplist);
	}
	else
	{
    
    
		SListNode* prev = *pplist;
		while (prev->next != pos)
		{
    
    
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
	}
}

La lista enlazada individualmente elimina el valor después de la posición pos.

void SListEraseAfter(SListNode* pos)
{
    
    
	assert(pos);
	assert(pos->next);
	
	SListNode* cur = pos->next->next;
	free(pos->next);
	pos->next = cur;
}