lista
lista de configuración simple : un puntero de cabeza (Header), una pluralidad de nodos (nodo comprende un campo de puntero y un campo de datos), para el último nodo a nulo (NULL).
El principio : el puntero de cabeza al primer nodo en la lista, a continuación, los primeros puntos de campo puntero nodo al siguiente nodo, y secuencialmente se refiere al último nodo, esto constituye una cadena.
estructura de datos de lista enlazada:
struct list_node
{
int data;//数据域，用于存储数据
struct list_node *next;//指针，可以访问节点数据，也可以遍历，指向下一个节点
};
Utilice la lista: No sé cómo declarar?
1. Los primeros punteros de cabeza comunicado: list_single node*=NULL;
2 y luego para abrir el espacio para: node=(list_single*)malloc(sizeof(list_single));
3. Uso de las funciones de la biblioteca memset a la estructura de vaciado rápido:
void *memset(void *s,int c,size_t n)-> que significa que:
el espacio de memoria se ha abierto a un valor del primer valor de s n bytes c.
Es decir: memset(node,0,sizeof(list_single));//清理一下
la lista 4. Asignación:
node->data=100;
node->next=NULL;
5. Utilice la lista: printf("%d\n",node->data);
6. espacio liberado, el final del programa.free(node);
Crear un nodo:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct list_node
{
int data;
struct list_node *next;
};
typedef struct list_node list_single;
int main(void)
{
list_single *node=NULL;
node=(list_single*)malloc(sizeof(list_single));
if(node==NULL){//?
printf("malloc fair!");
}
memset(node,0,sizeof(list_single));
node->data=100;
node->next=NULL;
printf("%d,%s",node->data,node->next);
return 0;
}
Simplemente crea una lista enlazada de nodos, el proceso se puede crear un paquete de funcionar, puede llamar cuando se crea!
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct list_node
{
int data;
struct list_node *next;
};
typedef struct list_node list_single;
list_single *creat_list_node(int data);//返回一个指针，即地址！
int main(void)
{
int data=100;
list_single *node=creat_list_node(data);
printf("%d,%s",node->data,node->next);
return 0;
}
list_single *creat_list_node(int data)
{
list_single *node=NULL;
node=(list_single*)malloc(sizeof(list_single));
memset(node,0,sizeof(list_single));
node->data=data;
node->next=NULL;
return node;
}
Ahora estamos simplemente creamos un nodo de la lista, entonces este nodo simple lista enlazada en las miradas de memoria así: define un puntero a la cabeza (datos, al lado) este campo de datos, los campos de datos puntos de campo siguiente puntero a NULL.
（ * node）->(data,next)->NULL
Vamos a crear una lista única de múltiples nodos para lograr CRUD! ! !
1. En primer lugar, una estructura de datos única lista enlazada arriba!
Igual que el anterior, sólo hay que poner la función crate_list_node anterior puede ser creado.
2. extremo del enchufe :( de enlace simple conexión de cadena lista)
que se implementa: Header> siguiente = new
Paso: posición del nodo actual adquisición, es decir, el primer nodo de acceso
struct list * p=header;
Segundo paso: determinar si un nodo es el último, si no, se mueve al siguiente nodo, si es así, los datos se inserta en una cola.
while(NULL!=p->next) p=p->next;
p->next=new;
3. cabezal único de la lista lista insertada :( inserción)
de inserción de la cabeza del nuevo nodo se inserta entre el nodo original siguiente nodo nodo y el nodo original.
El primer paso: Obtener la posición del nodo actual, que es el primer nodo de acceso
struct list * p=header;
El segundo paso: una nueva siguiente nodo al siguiente nodo del nodo de cabeza del original (dejó puntos al nodo a insertar más tarde)
new ->next=p->next;
El tercer paso: el siguiente nodo del nodo de cabeza del conjunto original como el nodo de cabecera recién insertado.
4. lista enlazada traversal:
Sabemos que la cabeza es un nodo de lista enlazada y una pluralidad de nodos, el último nodo en NULL.
Reflexión:
1. Tenemos que imprimir nodo principal hacer? (Sin nodo de cabezal de impresión, porque somos un nodo para facilitar la operación y ajuste)
2. Enumera el número de nodos de cómo lo sé? (Juzgando si el nodo es el nodo final, el punto de nodo final porque NULL)
entonces podemos ahora atravesar nuestra lista:
El primer paso: obtener la posición del nodo actual, que es el primer nodo de acceso
lista de estructura * p = cabecera;
segundo Tercer paso: Como el nodo principal que no es necesario imprimirlo, esta vez, el nodo de inicialización necesidades de impresión que empezar desde el primer nodo.
p = p-> siguiente;
El tercer paso: determinar si un nodo es el último, si no, los primeros datos de impresión al primer nodo (1), y después se mueve al siguiente nodo (2), repitiendo estos dos pasos.
1. while(NULL!=p-next){printf("node:%d\n",p->data);p=p->next;}
printf ( "Nodo: D% \ n", p-> Datos); // imprimir los puntos nulos último campo de datos;
2. paso puede ser impreso: while(NULL!=p>next){p=p->next;printf("node:%d\n",p->data);}
5, una lista única Eliminar
prototipo de eliminación se puede definir como:
int * detele_list_node(struct list* pH,int data);//指针、位置、数据
Para eliminar una lista única que considerar dos casos:
uno suprime el nodo común (por supuesto, el nodo principal no puede considerarse), a saber: punto de cambio, liberar la memoria!
También hay un caso antes de que un nodo final nodo eliminado, nota que la supresión del nodo también completamente libre de espacio en la memoria nodo correspondiente. A saber: el punto a NULL, liberar espacio.
Proceso de diseño:
primera etapa: definir dos punteros, uno para el nodo actual, y el otro representa el siguiente nodo actual.
struct list *p=header;//当前节点
struct list *prev=NULL;//当前节点的上一个节点
Paso dos: Traverse toda la lista, mientras que preserva el nodo actual anterior
while(NULL!=p->next)
{
//保存了当前节点的前一个节点
prev=p;
//保存当前偏移的节点
p=p->next;
return 0;
}
El tercer paso: encontrar los datos que desea eliminar en el proceso de recorrido
while(NULL != p->next)
{
//保存了当前的节点的前一个节点
prev = p ;
//保存当前偏移的节点
p = p->next ;
//查找到了数据
if(p->id == data)
{
}
return 0 ;
}
Cuarto paso: Encontrar puntos de datos para dos casos:
nodo común borrado
if(p->id == data)
{
prev->next = p->next ;
free(p);
}
考虑尾节点的下一个节点为NULL的节点删除
if(p->id == data)
{
if(p->next == NULL)
{
prev->next = NULL ;
free(p);
}
}
La sola cadena inversa:
pasos inversos:
Paso 1: Conjunto dos punteros, una primera posición de almacenamiento del nodo actual, un nodo representa una lista enlazada de válido
// guardar la posición actual del primer nodo
struct list *p=pH->next;
// representa una lista de nodos vinculados válido
struct list *pBack;
Paso Dos: Cuando no hay nodo o nodos válido tienen un válido, ninguna operación.
if(p==NULL||p->next==NULL)
return ;
El tercer paso: recorrido de lista
1. Guardar la primera dirección del siguiente nodo nodo
pBock=p->next;
2. El tratamiento especial para el primer nodo válida, que es el primer nodo válido en el extremo para ir.
if(p==pH->next)p->next=NULL;
3. Si no es un primer punto válido, se realiza la primera operación de interpolación, el nodo actual como un nuevo nodo:
p->next=pH->next;//尾部连接
pH->next=p//头部连接
4. Continuar por un nodo
p=pBack;
Paso cuatro: insertar manualmente el último nodo
top_insret(pH,p);
El flujo básico de una lista única para conocer, para escribir un programa! ! !
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct slist
{
int id ;
struct slist *next ;
}L;
//创建一个节点
L *create_node(int data)
{
//给每个节点分配结构体一样的空间大小
L *p = malloc(sizeof(L));
if(NULL == p)
{
printf("malloc error!\n");
return NULL ;
}
//由于结构体在未初始化的时候一样是脏数据，所以要清
memset(p,0,sizeof(L));
//初始化第一个节点
p->id = data ;
//将节点的后继指针设置为NULL
p->next = NULL ;
}
//链表的尾插
void tail_insert(L *pH , L *new)
{
//获取当前的位置
L *p = pH ;
//如果当前位置的下一个节点不为空
while(NULL != p->next)
{
//移动到下一个节点
p = p->next ;
}
//如果跳出以上循环，所以已经到了NULL的这个位置
//此时直接把新插入的节点赋值给NULL这个位置
p->next = new ;
}
//链表的头插
void top_insert(L *pH , L *new)
{
L *p = pH ;
new->next = p->next ;
p->next = new ;
}
//链表的遍历
void Print_node(L *pH)
{
//获取当前的位置
L *p = pH ;
//获取第一个节点的位置
p = p->next ;
//如果当前位置的下一个节点不为空
while(NULL != p->next)
{
//(1)打印节点的数据
printf("id:%d\n",p->id);
//(2)移动到下一个节点,如果条件仍为真，则重复(1)，再(2)
p = p->next ;
}
//如果当前位置的下一个节点为空，则打印数据
//说明只有一个节点
printf("id:%d\n",p->id);
}
//删除链表中的节点
int detele_list_node(L * pH , int data)
{
//获取当前头节点的位置
L *p = pH ;
L *prev = NULL;
while(NULL != p->next)
{
//保存当前节点的前一个节点的指针
prev = p ;
//然后让当前的指针继续往后移动
p = p->next ;
//判断，找到了要删除的数据
if(p->id == data)
{
//两种情况，一种是普通节点，还有一种是尾节点
if(p->next != NULL) //普通节点的情况
{
prev->next = p->next ;
free(p);
}
else //尾节点的情况
{
prev->next = NULL ; //将这个尾节点的上一个节点的指针域指向空
free(p);
}
return 0 ;
}
}
printf("没有要删除的节点\n");
return -1 ;
}
void trave_list(L * pH)
{
//保存第一个节点的位置
L *p = pH->next;
L *pBack;
int i = 0 ;
if(p->next == NULL || p == NULL)
return ;
while(NULL != p->next) //遍历链表
{
//保存第一个节点的下一个节点
pBack = p->next ;
//找到第一个有效节点,其实就是头指针的下一个节点
if(p == pH->next)
{
//第一个有效节点就是最后一个节点，所以要指向NULL
p->next = NULL ;
}
else
{
/*
new->next = p->next ;
p->next = new ;
*/
p->next = pH->next ; //尾部连接
}
pH->next = p ; //头部连接
p = pBack ; //走下一个节点
}
top_insert(pH,p); //插入最后一个节点
}
int main(int argc , char **argv)
{
//创建第一个节点
int i ;
L *header = create_node(0);
for(i = 1 ; i < 10 ; i++)
{
tail_insert(header,create_node(i));
}
Print_node(header);
detele_list_node(header,5);
putchar('\n');
Print_node(header);
putchar('\n');
trave_list(header);
Print_node(header);
return 0 ;
}
conexión Información relacionada:
https://blog.csdn.net/morixinguan/article/details/68951912
