两种方法实现单向链表的创建、遍历、删除、查找、逆序输出（循环法和递归法）

一个简单结点的结构体表示为： 

typdef struct note { 

int data； /*数据成员可以是多个不同类型的数据*/ 

struct note *next； /*指针变量，用于指向下一结点*/ 

}Node； 

链表特点：

1．链表是结构、指针相结合的-种应用,它是由头、中间、尾多个链环组成的可伸缩的链表,链表上的链环我们称之为结点。

2．每个结点的数据可用一个结构体表示,该结构体由两部分成员组成：数据成员与结构指针变量成员。

数据域和指针域

3．数据成员存放用户所需数据,而结构指针变量成员则用来连接(指向)下一个结点,由于每一个结构指针变量成员都指向相同的结构体,所以该指针变量称为结构指针变量。

4．链表的长度是动态的,当需要建立-个结点,就向系统申请动态分配-个存储空间,如此不断地有新结点产生,直到结构指针变量指向为空(NULL)。

5.节点的删除非常方便，不需要像线性结构那样移动剩下的数据

6节点的访问方便，可以通过循环或者递归的方法访问到任意数据，但是平均的访问效率低于线性表申请动态分配-个存储空间的表示形式为：

 (struct note*)malloc(sizeof(struct note))

一个简单的不规范的无头结点链表的例子：

#include

 #include

#define LEN sizeof(struct node)

typedef struct node

{

int data;

struct node *next;

}Node;

int main()

{ 

Node *p, *pl,* head;

head=p=(Node * )malloc(LEN);

scanf("%d",&p->data);/*头结点的数据成员*/

while(p->data != 0) /*给出0结束条件,退出循环*/

{ 

pl=p;

p=(Node * )malloc(LEN);scanf("%d",&p->data);/*中间结点数据成员*/pl->next=p;/*中间结点的指针成员值*/}

p-> next=NULL;/*尾结点的指针成员值*/p=head;/*链表显示*/

printf("链表数据成员是：");

while(p->next!=NULL)

{

printf("%d",p->data);

p=p->next;

}

printf("%d\n",p->data);

return 0;

}

递归法：

#include <stdio.h>
#include <stdlib.h>
//下文描述的所有结点均指LINK_NODE型的指针
typedef struct NODE  
{  
int data;  
struct NODE* next;  
}LINK_NODE;  
#define NULL 0
#define TRUE 1
#define FALSE -1
//删除指定链表,传入的参数是链表头结点的地址
void delete_node(LINK_NODE** headNode)  
{  
LINK_NODE** nextNode;  
if(NULL == headNode || NULL == *headNode)  
return ; //递归结束的条件 


nextNode = &( (*headNode)->next );//取得下一结点的地址 
free(*headNode);//注意要先取得下一结点的地址再释放该结点的空间 
delete_node(nextNode);//递归删除
}  
//
LINK_NODE* createNode(int value)
{
LINK_NODE* newNode = NULL;  
newNode = (LINK_NODE*)malloc(sizeof(LINK_NODE));  
if(NULL == newNode)//检验为结点分配内存是否成功
{
printf("malloc failed!\n");
return NULL;
}
newNode->data = value;  
newNode->next = NULL; //非常重要
return newNode;
}
//向指定链表插入新结点,value用于初始化新结点的数据域
int insertNode(LINK_NODE** headNode,LINK_NODE * newNode)  
{  
if(NULL == *headNode)//如果结点为空，则将新插入的结点赋值给该结点
{  
*headNode = newNode;  
return TRUE;
}  
return insertNode(&( (*headNode)->next ), newNode);//递归调用，直到所传入的结点为空 
}  
 
//删除指定结点，以数据域来作为指定条件
int deleteNode(LINK_NODE** headNode, int value)  
{  
LINK_NODE* nextNode;  
if(NULL == *headNode) //递归查找结束的标志 
return FALSE;  


if(value == (*headNode)->data)//判断要删除结点是否是头结点
{
nextNode = (*headNode)->next;
free(*headNode); //释放内存
*headNode = nextNode;//如果删除的点是头结点，则将头结点的下一个结点替换头结点
return 0;
}
return deleteNode(&(*headNode)->next, value);  
}  
//查找结点
LINK_NODE* find_node(const LINK_NODE* pLinkNode, int value)  
{  
if(NULL == pLinkNode)  
return NULL;  


if(value == pLinkNode->data)  
return (LINK_NODE*)pLinkNode;  


return find_node(pLinkNode->next, value);  
}  


//遍历链表
void print_node(const LINK_NODE* headNode)  
{  
if(headNode)
{  
printf("%d\n", headNode->data);  
print_node(headNode->next); //递归打印
}  
}  
//统计结点数
int count_node(const LINK_NODE* pLinkNode)  
{  
if(NULL == pLinkNode)  
return 0;  
return 1 + count_node(pLinkNode->next);  
}
int main()
{
int i;
LINK_NODE * newNode,*headNode = NULL;//注意，如果没有为头结点分配空间，一定要把头结点赋值为NULL
for(i=0;i<10;i++)
{
newNode = createNode(i);//创建结点
insertNode(&headNode,newNode);//插入结点
}
print_node(headNode);//遍历结点
int count = count_node(headNode);//统计结点数
printf("count = %d\n",count);


LINK_NODE *find = find_node(headNode,2);//查找结点
printf("find %d\n",find->data);//验证是否正确查找


deleteNode(&headNode,2);
print_node(headNode);//遍历结点
return 0;
}

递归调用法，效率较低，代码量较大，一般不用，这里仅贴出来作为学习之用。

循环法

#include <stdio.h>
#include <stdlib.h>
typedef struct node Node;//自定义结点指针类型
Node* head = NULL;//头结点定义为全局变量


//链表结点结构
//val 结点值
//next 指向下一结点的指针
struct node {
int val;
Node* next;
};


//在尾部插入节点函数
//返回值:0成功
//  -1失败
int insert(int val)
{
Node *p,*q;
if(NULL == head)
{
head = (Node*)malloc(sizeof(Node));
head->next = NULL;
}
p = head;
while(p->next != NULL)
p = p->next;//找到链表的末节点
q = (Node*)malloc(sizeof(Node));//创建一个新链表结点
if(q == NULL)//检验分配内存是否成功
{
printf("not enough mem!");
return -1;
}
q->next = NULL;//对新插入的结点进行赋值，新插入的结点在末尾，故next为空
q->val = val;
p->next = q;
return 0;//返回0表示执行成功
}


//将链表逆向
void reverse( Node **head )  
{  
Node *cur = NULL, *pre = NULL, *next = NULL;  


pre = *head;  
cur = (*head)->next;  
next = cur->next;  


//  反转第一个节点  
cur->next = NULL;  
pre = cur;  
cur = next;  


while( NULL != cur )  
{  
next = cur->next;  
cur->next = pre;  
pre = cur;  
cur = next;  
}  


(*head)->next = pre;  
}  
//遍历链表
void print()
{
Node* p = head->next;
while(p != NULL){
printf("%d\n",p->val);
p = p->next;//链表下移
}
}


//遍历链表，释放每一个节点
void destory()
{
Node* p = head;
Node* q;
while(p != NULL)
{
q = p;
p = p->next;
free(q);
}
head = NULL;
}
//删除一个节点
//用val来标识结点
//返回-1表示无此节点
//0表示成功删除
int del(int val)
{
Node *p;
Node *q;
if(NULL == head)
return 0;//空链表直接返回
p = head;
while(p != NULL)
{
if(p->val != val)
{
q = p;
p = p->next;//q是p的前一结点
}
else
{
q->next = p->next;
free(p);
return 0;
}
}
return -1;
}
void main(void)
{
int i;
for(i=0;i<10;i++)//插入十个节点
if(insert(i)  == -1)
{
printf("insert error\n");
exit(-1);
}
print();
del(2);
print();
reverse(&head);
print();
destory();
system("pause");
}

//将链表逆置的第二种方法

//将链表逆置：逆置结点的数据域
//  思路：定义一个指针数组，大小为链表大小，元素为指向链表节点的指针  
void reverse_data( Node **head )  
{  
Node *Cur = (*head)->next;  
int Len = 0, i = 0;  


//  1、计算链表长度  
while( NULL != Cur )  
{  
Len++;  
Cur = Cur->next;  
}  


//  2、动态声明指针数组，赋值  
Node **a = new Node *[Len];           
Cur = (*head)->next;  
while( NULL != Cur )  
{  
a[i++] = Cur;  
Cur = Cur->next;  
}  


//  3、逆置  
int low = 0, high = Len-1;  
int tmp;  
while( low < high )  
{  
tmp = a[low]->val;  
a[low]->val = a[high]->val;  
a[high]->val = tmp;  


low++;  
high--;  
}  


}  

下面再来一个例子，较为规范地实现对链表的封装。

此例的链表结构：

为一个链表定义一个数据结构，里面包含链表长度，头尾结点以及用于初始化、释放链表的函数指针。引入C++模板的话，可以实现泛型编程，使链表中的数据域适用于任何数据类型，这里不介绍。

typedef struct Node_  
{  
void *data;  
struct Node_ *next;  
}Node;  


/* define a structure for linked list */  
typedef struct List_  
{  
int size;  
int (*match)(const void *key1, const void *key2);  
void (*destroy)(void *data);  
Node *head;  
Node *tail;  
}List;  


/* define public interface */  
void list_init(List *list, void(*destroy)(void *data));  
void list_destroy(List *list);  
int list_insert_next(List *list, Node *newNode, const void *data);  
int list_remove_next(List *list, Node *newNode, void **data);  


#define list_size(list) ((list)->size)  


#define list_head(list) ((list)->head)  
#define list_tail(list) ((list)->tail)  


#define list_is_head(list, node) ((node) == (list)->head ? 1 : 0)  
#define list_is_tail(list, Node) ((Node) == (list)->tail ? 1 : 0)  


#define list_data(node) ((node)->data)  
#define list_next(node) ((node)->next)  


void list_init(List *list, void (*destroy)(void *data))  
{  
list->size = 0;  
list->destroy = destroy;  
list->head = NULL;  
list->tail = NULL;  
return;  
} 


/* list_destroy */  
void list_destroy(List *list)  
{  
void *data; //keep the data in the element of the list  


/*remove the element */  
while( list_size(list) > 0 )   
{  
if(list_remove_next(list, NULL, (void **)&data) == 0 && list->destroy != NULL)  
{  
list->destroy(data);  
}  
}  
memset(list, 0, sizeof(list));  
return;  
}  
/* destroy */  
void destroy(void *data)  
{  
printf("in destroy\n");  
free(data);  
return;  
}  
//elment不为空时，在该结点后面插入，为空时，在头结点前面插入。
int list_insert_next(List *list, Node *element, const void *data)  
{  
/* Allocate storage */  
Node *new_element = NULL;  
new_element = (Node *)malloc(sizeof(Node));  
if( new_element == NULL )  
return -1;  


new_element->data = (void *)data;  
/* Insert the element into the list */  
if( element == NULL ) //from head position to insert  
{  
if( list_size(list) == 0 )  //be care to tail  
list->tail = new_element;  //如果链表为空，则让新插入的结点称为尾结点


new_element->next = list->head;  //让新插入的结点指向头结点，此例头结点是由数据的。
list->head = new_element;//如果链表为空，则会让新插入的结点称为头结点
}  
else  
{  
if( element->next == NULL ) //be care to tail  
list->tail = new_element;  //如果指定的结点末尾为空，说明是尾结点，记得要更新尾结点


new_element->next = element->next;  
element->next = new_element;  
}  
/*Adjust size */  
list->size++;  
return 0;  
} 


//删除指定结点的下一结点，如果指定结点为空，则从头结点开始删除，如果指定结点的下一结点为空，则不用删除
int list_remove_next(List *list, Node *element, void **data)  
{  
Node *old_element;  


//if the list is empty  
if( list_size(list) == 0 )  
return -1;  


/* Remove the element from the list */  
if( element == NULL ) //from head to remove  
{  
*data = list->head->data; //keep the data.  
old_element = list->head;  //取出要删除的结点，后面要释放它的空间
list->head = list->head->next;  


if( list_size(list) == 1 )  //be care to the tail ，大小为1，说明删除的是尾结点，记得更新尾结点。 
list->tail = NULL;  
}  
else  
{  
//if the element to be removed is NULL  
if( element->next == NULL )  
return -1;  


*data = element->next->data;  
old_element = element->next;  
element->next = element->next->next;  


if( element->next == NULL ) //be care to the tail  
list->tail = element;  
}  


//free the memory  
free(old_element);  


list->size--;  
return 0;  
}