Self-fulfilling single-linked list

Simple operation of a single linked list, please correct me.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct{
Char key[10];
Char name[20];
int age;
}data;

typedef struct NODE
{
Data Nodedata;
struct Node *nextnode;
}cltype,*pcltype;

extern cltype *cl_add_end (Cltype *head,data nodedata);
extern cltype *cl_add_first (Cltype *head,data nodedata);
extern cltype *cl_insert_node (cltype *head,char *findkey,data nodedata);
extern cltype *cl_del_head (Cltype *head);
extern void Cl_del_head_v2 (Cltype **head);
extern void Cl_del_tail (Cltype **head);
extern int Cl_del_node (Cltype **head,char *delkey);
extern void Cl_clear_all (Cltype **head);
extern cltype *cl_find_node (Cltype *head,char *findkey);
extern int cl_get_length (Cltype *head);
extern void Cl_show_node (Cltype *node);
extern void Cl_show_all (Cltype *head);
extern cltype *cl_sort_insert (Cltype *head);

/**************************************************************************************/
/* Tail Join */
Cltype *cl_add_end (cltype *head,data nodedata)
{
Cltype *node = NULL;
Cltype *temp = NULL;
node = (cltype*) malloc (sizeof (Cltype));
if (NULL = = node) {
printf ("malloc node error!!");
return NULL;
}
Node->nodedata = Nodedata;
Node->nextnode = NULL;
if (NULL = = head) {
Head = node;
return head;
}
temp = head;
while (NULL! = Temp->nextnode) {
temp = temp->nextnode;
}
Temp->nextnode = node;
return head;
}

/* Add from scratch */
Cltype *cl_add_first (cltype *head,data nodedata)
{
Cltype *node = NULL;
node = (cltype*) malloc (sizeof (Cltype));
if (NULL = = node) {
printf ("malloc node error!!");
return NULL;
}
Node->nodedata = Nodedata;
Node->nextnode = head;
Head = node;
return head;
}

/* Insert Node */
Cltype * Cl_insert_node (cltype *head,char *findkey,data nodedata)
{
Cltype *node = NULL;
Cltype *temp = NULL;
node = (cltype*) malloc (sizeof (Cltype));
if (NULL = = node) {
printf ("malloc node error!!");
return NULL;
}
Node->nodedata = Nodedata;
temp = Cl_find_node (Head,findkey);
if (NULL! = temp) {
Node->nextnode = temp->nextnode;
Temp->nextnode = node;
}else{
printf ("Not find key node!!");
Free (node);
}
return head;
}
/**************************************************************************************/
/* Remove head */
Cltype * Cl_del_head (Cltype *head) {
Cltype *temp = NULL;
temp = head;
Head = temp->nextnode;
Free (temp);
return head;
}
/* Remove head */
void Cl_del_head_v2 (Cltype **head) {
Cltype *temp = NULL;
temp = *head;
*head = temp->nextnode;
Free (temp);
}

/* Delete Tail */
void Cl_del_tail (Cltype **head) {
Cltype *temp = NULL;
Cltype *node = NULL;
temp = *head;
node = *head;
if (Cl_get_length (*head) ==1) {
CL_DEL_HEAD_V2 (head);
return;
}
while (NULL! = Temp->nextnode) {
node = temp;
temp = temp->nextnode;
}
Node->nextnode = NULL;
Free (temp);
}
/* Delete a node */
int Cl_del_node (Cltype **head,char *delkey) {
Cltype *temp = NULL;
Cltype *node = NULL;
temp = *head;
node = *head;
if (strcmp (Temp->nodedata.key,delkey) ==0) {
CL_DEL_HEAD_V2 (head);
return 1;
}
while (NULL! = temp) {
if (strcmp (Temp->nodedata.key,delkey) ==0) {
Node->nextnode = temp->nextnode;
Free (temp);
return 1;
}
node = temp;
temp = temp->nextnode;
}
return 0;
}
/* Clean up */
void Cl_clear_all (Cltype **head)
{
Cltype *temp;
while (NULL! = *head) {
temp = (*head)->nextnode;
Free (*head);
(*head) = temp;
}
}
/**************************************************************************************/
/* Find nodes */
Cltype *cl_find_node (cltype *head,char *findkey)
{
Cltype *temp = head;
while (NULL! = temp) {
if (strcmp (Temp->nodedata.key,findkey) ==0) {
return temp;
}
temp = temp->nextnode;
}
return NULL;
}
/* Length */
int Cl_get_length (Cltype *head) {
Cltype *node = NULL;
Cltype *temp = NULL;
int len = 0;
temp = head;
while (NULL! = temp) {
len++;
temp = temp->nextnode;
}
return Len;
}
/**************************************************************************************/
/* Display */
void Cl_show_node (Cltype *node)
{
if (NULL! = node) {
printf ("node key=%s name =%s age=%d\n", Node->nodedata.key,
Node->nodedata.name,node->nodedata.age);
}
}
/* Show All */
void Cl_show_all (Cltype *head)
{
Cltype *temp = NULL;
Data Nodedata;
memset (&nodedata,0,sizeof (Data));
temp = head;
while (NULL! = temp) {
Nodedata = temp->nodedata;
printf ("nodedata key=%s name =%s age=%d\n", nodedata.key,nodedata.name,nodedata.age);
temp = temp->nextnode;
}
}
/**************************************************************************************/
/* Sort */
Cltype *cl_sort_insert (Cltype *head)
{
Cltype *p = head;
Cltype *minnode = head;
Cltype *pstart = NULL;
Cltype*sortedtail = NULL;
Data temp;
if (head = = NULL | | head->nextnode = = NULL)
return head;

Pstart = (cltype*) malloc (sizeof (Cltype));
Pstart->nextnode = head; For ease of operation, add a head node.
Sortedtail = pstart;//points to the tail of the ordered part

while (Sortedtail->nextnode! = NULL) {
Minnode = sortedtail->nextnode;
p = sortedtail->nextnode->nextnode;
Finding the smallest node of an unordered part
while (P! = NULL) {
if (P->nodedata.age < minnode->nodedata.age)
Minnode = p;
p = p->nextnode;
}
temp = minnode->nodedata;
Minnode->nodedata = sortedtail->nextnode->nodedata;
Sortedtail->nextnode->nodedata = temp;
Sortedtail = sortedtail->nextnode;
}

Head = pstart->nextnode;
Free (Pstart);
return head;
}
/**************************************************************************************/
int main ()
{
Cltype * head = NULL;
Cltype * Findnode = NULL;
Data Nodedata;
int iage=0;
int total_num;
printf ("Number of inputs:");
scanf ("%d", &total_num);
for (; iage<total_num;iage++)
{
memset (&nodedata,0,sizeof (Data));
scanf ("%s%s%d", nodedata.key,nodedata.name,&nodedata.age);
//head = Cl_add_first (Head,nodedata);
Head = cl_add_end (head,nodedata);
}
printf ("Length =%d\n", Cl_get_length (head));
Findnode=cl_find_node (Head, "2");
Cl_show_node (Findnode);
Cl_show_all (head);
printf ("\n\ninsert******************\n");
memset (&nodedata,0,sizeof (Data));
scanf ("%s%s%d", nodedata.key,nodedata.name,&nodedata.age);
Cl_insert_node (Head, "2", nodedata);
Cl_show_all (head);

printf ("\n\ndelete 2******************\n");
CL_DEL_HEAD_V2 (&head);
Cl_del_node (&head, "1");
Cl_del_tail (&head);
Cl_show_all (head);

printf ("\ n" sort 2******************\n ");
Head=cl_sort_insert (head);
Cl_show_all (head);
printf ("\n\nclear******************\n");
Cl_clear_all (&head);

Getch ();
return 1;
}

Self-fulfilling single-linked list