链表的简单创建——C程序设计

题目：创建固定长度的单向链表

程序分析：链表是动态分配存储空间的链式存储结构，

其包括一个“头指针”变量，其中第0个结点称为整个链表的头结点，头结点中存放一个地址，该地址指向一个元素，头结点一般不存放具体数据，只是存放第一个结点的地址。

链表中每一个元素称为“结点”，每个结点都由两部分组成：存放数据元素的数据域和存储直接后继存储位置的指针域。指针域中存储的即是链表的下一个结点存储位置，是一个指针。多个结点链接成一个链表。

最后一个结点的指针域设置为空(NULL)，作为链表的结束标志，表示它没有后继结点。

使用结构体变量作为链表中的结点，因为结构体变量成员可以是数值类型，字符类型，数组类型，也可以是指针类型，这样就可以使用指针类型成员来存放下一个结点的地址，使其它类型成员存放数据信息。

在创建列表时要动态为链表分配空间，C语言的库函数提供了几种函数实现动态开辟存储单元。

malloc()函数实现动态开辟存储单元：

      malloc函数原型为：void *malloc(unsigned int size);

      其作用是在内存的动态存储区中分配一个长度为size的连续空间，函数返回值是一个指向分配域起始地址的指针（类型为void）。如果分配空间失败（如，内存空间不足），则返回空间指针（NULL）

代码如下：

#include<stdio.h>
#include<malloc.h>
struct LNode
{
int data;
struct LNode *next;
};
/*上面只是定义了一个结构体类型，并未实际分配内存空间
只有定义了变量才分配内存空间*/
struct LNode *creat(int n)
{
int i;
struct LNode *head,*p1,*p2;
/*head用来标记链表，p1总是用来指向新分配的内存空间，
p2总是指向尾结点，并通过p2来链入新分配的结点*/
int a;
head=NULL;
for(i=1;i<=n;i++)
{
p1=(struct LNode *)malloc(sizeof(struct LNode));
/*动态分配内存空间，并数据转换为(struct LNode)类型*/
printf("请输入链表中的第%d个数：",i);
scanf("%d",&a);
p1->data=a;
if(head==NULL)/*指定链表的头指针*/
{
head=p1;
p2=p1;
}
else
{
p2->next=p1;
p2=p1;
}
p2->next=NULL;/*尾结点的后继指针为NULL(空)*/
}
return head;/*返回链表的头指针*/
}
void main()
{
int n;
struct LNode *q;
printf("请输入链表的长度：/n");
scanf("%d",&n);
q=creat(n);/*链表的头指针(head)来标记整个链表*/
printf("/n链表中的数据：/n");
while(q)/*直到结点q为NULL结束循环*/
{
printf("%d ",q->data);/*输出结点中的值*/
q=q->next;/*指向下一个结点*/
}
}

题目：创建双向链表

程序分析：双向链表的结点有两个指针域，一个指向其直接后继，另一个指向其直接前驱。其中第一个结点的前驱为NULL（头结点为第0个结点），最后一个结点的后继为NULL。

代码如下：

#include<stdio.h>
#include<string.h>
#include<malloc.h>
typedef struct node
{
char name[20];
struct node *prior,*next;
}stud;
/*双链表的结构定义*/
stud *creat(int n)/*创建双链表函数*/
{
stud *p,*h,*s;
int i;
h=(stud *)malloc(sizeof(stud));/*动态分配内存赋予头结点*/
h->name[0]='/0';/*为头结点的内容置空*/
h->prior=NULL;/*头结点的前驱和后继置为NULL*/
h->next=NULL;
p=h;/*将头结点赋值于p，p总是指向链表的最后一个结点*/
for(i=0;i<n;i++)
{
s=(stud *)malloc(sizeof(stud));/*动态分配内存*/
p->next=s;/*让p结点的后继指向s*/
printf("请输入第%d个同学的名字：",i+1);
scanf("%s",s->name);
s->prior=p;/*让s结点的前驱指向p结点*/
s->next=NULL;/*让s结点的后继指向NULL，s总是指向新分配的结点*/
p=s;/*p总是指向链表的最后一个结点*/
}
p->next=NULL;/*双链表的最后一个结点的后继指向NULL*/
return(h);
}
stud *search(stud *h,char *x)/*查找*/
{
stud *p;/*用于定位双链表中的结点*/
char *y;
p=h->next;
while(p)
{
y=p->name;
if(strcmp(y,x)==0)/*strcmp函数比较两个字符串的内容是否相等*/
return (p);/*若找到，返回当前结点*/
else
p=p->next;/*不相等就继续向下查找*/
}
printf("信息未找到/n");
}
void del(stud *p)/*删除*/
{
if(p->next!=NULL)/*确定要删除的结点是否为最后一个结点，最后一个结点后继为NULL*/
p->next->prior=p->prior;/*p结点后继的前驱赋予p结点的前驱*/
p->prior->next=p->next;/*p结点前驱的后继赋予p结点的后继*/
free(p); /*释放p结点的内存空间*/
}
void dip(stud *p) /*输出双链表*/
{
while(p)
{
printf("%s ",&*(p->name));
/*%s格式符要用字符数组的起始地址即第一个字符的地址，也可用(p->name)*/
p=p->next;
}
}
void main()
{
int number;
char sname[20];
stud *head,*sp; /*head用来标记双链表，sp用来定位结点*/
puts("请输入链表的长度：");
scanf("%d",&number);
head=creat(number);
sp=head->next; /*sp指向双链表的第一个结点(头结点为第0个结点)*/
printf("/n双链表内的数据为：/n");
dip(sp); /*输出链表*/
printf("/n请输入要查找的学生姓名：/n");
scanf("%s",sname);
sp=search(head,sname); /*查找链表中的结点*/
printf("/n你想要找的名子是：%s/n",&*(sp->name));
del(sp); /*删除sp结点*/
sp=head->next;
printf("/n现在的双链表是：/n");
dip(sp); /*输出链表*/
printf("/n");
}

题目：创建循环链表

程序分析：循环链表与普通链表的操作基本一致，

只是链表中最后一个结点的指针域指向头结点，是链表形成一个环，

从表中的任一结点出发均可找到表中的其它结点

在算法中循环遍历链表是判断条件不再是p->next是否为空，

而是是否等于链表的头指针。

代码如下：

#include<stdio.h>
#include<malloc.h>
typedef struct student
{
int num;
struct student *next;
}LNode,*LinkList;
/*定义链表的结构体类型*/
LinkList creat(void)
{
LinkList head;
LNode *p1,*p2;
/*p1用来指向新分配的结点，
p2始终指向链表的最后一个结点，
同时用p2->next=p1来链入新结点*/
char a;
head=NULL;/*新创建的链表的头指针为NULL(空)*/
a=getchar();
while(a!='/n')
{
p1=(LNode *)malloc(sizeof(LNode));/*动态分配内存空间*/
p1->num=a;/*为结点的数据域赋值*/
if(head==NULL)/*指定链表的头指针*/
head=p1;
else
p2->next=p1;/*将新结点p1链入链表*/
p2=p1;/*p2指向刚链入的新结点，即让p2始终指向链表的最后一个结点*/
a=getchar();
}
p2->next=head;/*链表的最后一个结点的后继指向头结点*/
return head;
}
void main()
{
LinkList L1,head;
printf("/n请输入循环链表内容：/n");
L1=creat();/*创建链表*/
head=L1;
printf("/n循环链接表：/n");
printf("%c",L1->num);
L1=L1->next;
while(L1!=head)
{
/*判断条件为循环到头结点结束*/
printf("%c",L1->num);
L1=L1->next;
}
printf("/n/n");
}