liste
liste de configuration simple : un pointeur de tête ( en- tête), une pluralité de noeuds (noeud comprend un champ de pointeur et un champ de données), le dernier noeud à zéro (NULL).
Le principe : le pointeur de tête vers le premier noeud dans la liste, alors le premier point de champ de pointeur de noeud vers le noeud suivant, et se rapporte séquentiellement au dernier noeud, ce qui constitue une chaîne.
structure de données de liste chaînée:
struct list_node
{
int data;//数据域，用于存储数据
struct list_node *next;//指针，可以访问节点数据，也可以遍历，指向下一个节点
};
Utilisez la liste: Je ne sais pas comment déclarer?
1. Les premiers pointeurs de tête de l' instruction: list_single node*=NULL;
2, puis d'ouvrir l' espace pour: node=(list_single*)malloc(sizeof(list_single));
3. Utilisez les fonctions de bibliothèque memset à la structure rapidement vidée:
void *memset(void *s,int c,size_t n)-> cela signifie que:
l'espace mémoire a été ouvert à une valeur de la première valeur des octets de n c.
C'est: memset(node,0,sizeof(list_single));//清理一下
4. Liste des affectations:
node->data=100;
node->next=NULL;
5. Utilisez la liste: printf("%d\n",node->data);
6. espace libéré, la fin du programme.free(node);
Créer un nœud:
#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;
}
Il crée simplement une liste chaînée de noeuds, le processus que nous pouvons créer un package à la fonction, vous pouvez appeler lorsque vous créez!
#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;
}
Nous sommes maintenant à créer un nœud de liste, cette liste chaînée un seul nœud dans les regards de mémoire comme celle-ci: définir un pointeur vers la tête (données, à côté) ce champ de données, le champ de points de données à côté du champ de pointeur vers un NULL.
（ * node）->(data,next)->NULL
Créons une liste unique de multiples nœuds pour atteindre CRUD! ! !
1. Tout d' abord, une seule structure de données haut de liste chaînée!
Comme ci - dessus, il suffit de mettre la fonction crate_list_node ci - dessus peut être créé.
2. Bouchon de fin :( chaînée simple connexion en chaîne de la liste)
qui est mis en oeuvre: header-> next = new
étape: acquérir la position du noeud courant, à savoir le premier noeud d'accès
struct list * p=header;
Deuxième étape: déterminer si un noeud est le dernier, si non, se déplace vers le noeud suivant, dans l'affirmative, les données sont insérées dans une queue.
while(NULL!=p->next) p=p->next;
p->next=new;
3. une tête de la liste de la liste insérée :( insertion)
insertion de la tête du nouveau noeud est inséré entre le noeud suivant du noeud noeud d' origine et le noeud d' origine.
La première étape: obtenir la position du noeud courant, qui est le premier noeud d'accès
struct list * p=header;
La deuxième étape: un nouveau noeud suivant au noeud suivant du noeud de tête de l'original (laisser pointe vers le noeud doit être inséré plus tard)
new ->next=p->next;
La troisième étape: le noeud suivant du noeud de tête de l'ensemble d' origine en tant que noeud de tête nouvellement inséré.
4. liste chaînée traversal:
Nous savons que la tête est un nœud de liste chaînée et une pluralité de noeuds, le dernier nœud à NULL.
Réflexion:
1. Nous avons besoin d'imprimer nœud de tête faire? (Sans nœud de tête d'impression, parce que nous sommes un noeud pour la facilité d'utilisation et le réglage)
2. Cet article répertorie le nombre de nœuds que je sais? (En jugeant si le noeud est le noeud final, le point de noeud final , car NULL)
alors nous pouvons maintenant parcourir notre liste:
La première étape: Obtenir la position du noeud courant, qui est le premier noeud d' accès
liste struct * p = tête;
seconde Troisième étape: Comme le nœud de tête on n'a pas besoin d'imprimer, cette fois, le nœud initialize besoins d' impression à partir du premier noeud.
p = p-> suivant;
La troisième étape: déterminer si un noeud est le dernier, si non, les premières données d'impression vers le premier noeud (1), et se déplace ensuite vers le noeud suivant (2), en répétant les deux étapes.
1. while(NULL!=p-next){printf("node:%d\n",p->data);p=p->next;}
le printf ( « Noeud: D% \ n », p> données); // imprimer le dernier champ de points de données nuls;
2. étape peut être imprimé: while(NULL!=p>next){p=p->next;printf("node:%d\n",p->data);}
5, une seule liste Supprimer
prototype Supprimer peut être définie comme:
int * detele_list_node(struct list* pH,int data);//指针、位置、数据
Pour supprimer une liste unique à considérer deux cas:
un noeud commun supprimé (bien sûr, le nœud principal ne peut pas être considéré) , à savoir: point de changement, libérer la mémoire!
Il y a aussi un cas avant un noeud final de noeud supprimé, notez que la suppression du nœud libérer aussi complètement noeud correspondant espace mémoire. A savoir: le point à NULL, libérer de l' espace.
Processus de conception:
première étape: définir deux pointeurs, l' un pour le noeud courant, et l'autre représente le noeud suivant courant.
struct list *p=header;//当前节点
struct list *prev=NULL;//当前节点的上一个节点
Deuxième étape: parcourir la liste entière, tout en préservant le noeud courant précédent
while(NULL!=p->next)
{
//保存了当前节点的前一个节点
prev=p;
//保存当前偏移的节点
p=p->next;
return 0;
}
La troisième étape: trouver les données à supprimer dans le processus de traversal
while(NULL != p->next)
{
//保存了当前的节点的前一个节点
prev = p ;
//保存当前偏移的节点
p = p->next ;
//查找到了数据
if(p->id == data)
{
}
return 0 ;
}
Quatrième étape: Trouver des points de données à deux cas:
noeud commun supprimé
if(p->id == data)
{
prev->next = p->next ;
free(p);
}
考虑尾节点的下一个节点为NULL的节点删除
if(p->id == data)
{
if(p->next == NULL)
{
prev->next = NULL ;
free(p);
}
}
L'inverse chaîne unique:
étapes inverse:
Etape 1: Placez deux pointeurs, une première position de stockage du noeud courant, un nœud représente une liste chaînée de valide
// enregistrer la position actuelle du premier noeud
struct list *p=pH->next;
// représente une liste chaînée de noeud valide
struct list *pBack;
Deuxième étape: Si aucun noeud valide ou les noeuds ont un valide, aucune opération.
if(p==NULL||p->next==NULL)
return ;
La troisième étape: liste traversal
1. Enregistrez la première adresse du prochain noeud noeud
pBock=p->next;
2. Le traitement spécial pour le premier noeud valide, qui est le premier noeud valide dans la fin aller.
if(p==pH->next)p->next=NULL;
3. Si ce n'est pas un premier point valide, la première opération d'interpolation est effectuée, le noeud courant comme un nouveau noeud:
p->next=pH->next;//尾部连接
pH->next=p//头部连接
4. Continuer sur un noeud
p=pBack;
Quatrième étape: insérer manuellement le dernier noeud
top_insret(pH,p);
Le débit de base d'une liste unique pour faire connaissance, ici pour écrire un programme! ! !
#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 ;
}
Connexion Référence connexe:
https://blog.csdn.net/morixinguan/article/details/68951912
