一个简单结点的结构体表示为:
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;
}