创建单链表c语言

‘壹’ c语言 单链表的创建

*creat a list*/
#include "stdlib.h"
#include "stdio.h"
struct list
{ int data;
struct list *next;
};
typedef struct list node;
typedef node *link;
void main()
{ link ptr,head;
int num,i;
ptr=(link)malloc(sizeof(node));
ptr=head;
printf("please input 5 numbers==>\n");
for(i=0;i<=4;i++)
{
scanf("%d",&num);
ptr->data=num;
ptr->next=(link)malloc(sizeof(node));
if(i==4) ptr->next=NULL;
else ptr=ptr->next;
}
ptr=head;
while(ptr!=NULL)
{ printf("The value is ==>%d\n",ptr->data);
ptr=ptr->next;
}
}

上面是一个简单的创建链表的C程序。所谓链表形象的讲就是一个数据块里面存有数据，并且存有下一个数据的指针，这样一个指一个形成一个数据链。这个数据链可以被操作，例如插入数据，删除数据，等。至于指令，首先定义一个结构体，它存有数据和指向下一个数据块的指针。然后分配空间。注意最后一个为NULL，当然你也可以指向开头一个数据块形成一个循环链表

‘贰’ 如何用C语言创建单链表！！！！！

用一个结构体
struct Node{
int value;
struct Node *next;
};
value是这个元素的值，*next是指向想一个或颂元素的指针，
跟数组的比较，数组可以直接通过下标查询其中的元素比如a[9],而单链表只能遍历第9个元素以前的所有元素才能找到第9个元素。单链冲举表的插散团碧入和删除比数组简单

‘叁’ C语言中单链表的创建

struct infor
{
char name[10];//学生名称
int age;//年龄
struct infor *next;//存储下一个结构的地址
};//链表的数据结构

struct infor *head=NULL;//头指针，指向第一个结构
struct infor *p,*c;//*p：是当前结构的前一个结构地址；*c：当前指针
char buf[10];//存放name的临时数组
printf("Enter name:");//提示
while(scanf("%s",buf)==1 && buf[0]!='0')//name输入0时结束
{
c=(struct infor *)malloc(sizeof(struct infor));//给结构分配内存
if(c==NULL)/无法分配内存
{
printf("No memory");
exit(1);
}
if(head==NULL)
{
head=c;//第一个结构核碧地址
}
else
{
p->next=c;//下一个结构的地址
}
c->next=NULL;//表示最后一个结构
strcpy(c->name,buf);//拷贝name到链表中
printf("Enter age:");
scanf("%d",&c->age);//输入年龄
p=c;//指向埋氏陵前一个节点
printf("Enter name:");
}
c=head;
while(c!=NULL)
{
printf("name=%s age=%d\n",c->name,c->age);
c=c->next;
}//读取链表中的信息
printf("over\n");
c=head;
while(c!=NULL)
{
free(c);
c=c->next;
}//释放内存
运行结果：
Enter name:Jim
Enter age:25
Enter name:Tom
Enter age:36
Enter name:Jack
Enter age:65
Enter name:0
name=Jim age=25
name=Tom age=36
name=Jack age=65
over
//以上程序直接加到主函数中运行正弯戚常

‘肆’ c语言构建一个最简单的单链表

typedef struct node { char name[20]; struct node *link; }stud; 下面就来看一个建立带表头搜弊（若未说明，以下所指 链表 均带表头）的单 链表 的完整程序。 #include ＜stdio.h＞ #include ＜malloc.h＞ /*包含动态内存分配函数的头文件*/ #define N 10 /*N为人数*/ typedef struct node { char name[20]; struct node *link; }stud; stud * creat(int n) /*建立单 链表 的函数，形参n为人数*/ { stud *p,*h,*s; /* *h保存表头结点的指针，*p指向当前结点的前一个世碰族结点，*s指向当前结点*/ int i; /*计数器*/ if((h=(stud *)malloc(sizeof(stud)))==NULL) /*分配空间并检测*/ { printf("不能分配内存空间!"); exit(0); } h-＞name[0]='\0'; /*把表头结点的数据域置空*/ h-＞link=NULL; /*把表头结点的链域置空*/ p=h; /*p指向表头结点*/ for(i=0;i＜n;i++) { if((s= (stud *) malloc(sizeof(stud)))==NULL) /*分配新存储空间并检测*/ { printf("不能分配内存空间!"); exit(0); } p-＞link=s; /*把s的地址赋给p所指向的结点的链域，这样就把p和s所指向的结点连接起来了*/ printf("请输入第%d个人的姓名",i+1); scanf("%s",s-＞name); /*在当前结点s的数据域中存储姓名*/ s-＞link=NULL; p=s; } return(h); } main() { int number; /*保存人数的变量*/ stud *head; /*head是保存单 链表 的表头结点地址的指针*/ number=N; head=creat(number); /*把所新建的单 链表 表头地址赋给head*/ } 这样就写好了一个可以建吵芦立包含N个人姓名的单 链表 了。写动态内存分配的程序应注意，请尽量对分配是否成功进行检测。

‘伍’ c语言创建单链表

#include<stdio.h>
#include<stdlib.h>
/*线性表*/
struct TLink {
int data;
struct TLink * next;
};/*end struct TLink*/

/*生成新元素*/
struct TLink * new_item(int number)
{
struct TLink * r = 0;
r = (struct TLink *)malloc(sizeof(struct TLink));
r->data = number;
r->next = 0;
return r;
}/*end new_item*/

/*在线性表中查询数据*/
struct TLink * lookup(struct TLink * root, int number)
{
struct TLink * h = root;
while(h) {
if (h->data == number) return h;
h = h->next ;
}/*end lookup*/
return 0;
}

/*在线性表中追加一个数据*/
void append(struct TLink * * root, int number)
{
struct TLink * r = 0, * n = 0;
if (!root) return ;

/*不记录重复元素*/
if (lookup(*root, number)) return;

/*如果表为空则新建表*/
r = *root;
if (!r) {
*root = new_item(number);
return ;
}/*end if*/

/*为保证为有序线性表，如果数据比表头还小则作为表头*/
if (number < r->data ) {
n = new_item(number);
n->next = r;
*root = n;
return ;
}/*end if*/

/*在有序线性表中查找位置插入元素*/
while(r) {
n = r->next ;

/*如果已经是表尾则直接追加*/
if (!n) {
n = new_item(number);
r->next = n;
return ;
}/*end if*/

/*在中央某处插入*/
if (number < n->data ) {
r->next = new_item(number);
r->next->next = n;
return ;
}/*end if*/
r = n;
}/*end while*/
}/*end append*/

/*打印有序线性表*/
void print(struct TLink * root)
{
struct TLink * r = root;
printf("【");
while(r) {
printf("%d ", r->data );
r = r->next ;
}/*end while*/
printf("\b】\n");
}/*end print*/

/*将有序线性表h1合并至有序线性表h0，并销毁线性表h1*/
void merge(struct TLink ** h0, struct TLink ** h1)
{
struct TLink * h = 0, * k = 0;
if (!h0 || !h1) return ;
h = *h1;
while(h) {
append(h0, h->data );
k = h;
h = h->next ;
free(k);
}/*end h*/
h1 = 0;
}

int main(void)
{
int i = 0; struct TLink * x=0, *y = 0;
int a[] = {8,4,3,9,5,1};
int b[] = {7,2,1,5,6,0};
printf("原数据为：\n数组A：【");
for(i = 0; i < 6; i++) {
printf("%d ", a[i]);
append(&x, a[i]);
}/*next*/
printf("\b】\n数组B：【");
for(i = 0; i < 6; i++) {
printf("%d ", b[i]);
append(&y, b[i]);
}/*next*/
printf("\b】\n转换为有序线性表\nA：");
print(x);
printf("B：");
print(y);
printf("AB合并后为：");
merge(&x, &y);
print(x);
return 0;
}

/*以上是顺序线性表的合并程序，逆序只需将插入条件从小于改为大于即可。
合并结果如果要保留，把合并函数的lookup调用删除即可*/

‘陆’ 用C语言创建一个具有10个元素的单链表

#include <stdio.h>

#include<stdlib.h>

typedef struct List

{

int e;

struct List *next;

}List;

void initList(List *head)

{

int n,i;

List *p,*q;

scanf("%d",&n);

p=head;

for(i=0;i<n;i++)

{

q=(List*)malloc(sizeof(List));

if(!q)

return;

scanf("%d",&q->e);

q->next=NULL;

p->next=q;

p=p->next;

}

}

void displayList(List *head)

{

List *p;

for(p=head->next;p;p=p->next)

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

printf(" ");

}

void destoryList(List *head)

{

List *p;

while(head->next) {

p=head->next;

head->next=p->next;

free(p);

}

free(head);

}

void insertList(List *head,int x)

{

List *p=head;

while(p->next) {

p=p->念陪next;

}

p->next=(List*)malloc(sizeof(List));

p->next->e=x;

p->next->仔册蠢next=NULL;

}

void deleteList(List *head,int x)

{

List *p,*pre;

int flag=1;

for(p=head->next;p;p=p->next)

{

if(p->e==x)

{

pre->next=p->next;

free(p);

p=pre;

flag=0;

}

pre=p;

}

if(flag)

printf("No element to delete! ");

}

int main()

{

int x;

List *head=(List*)malloc(sizeof(List));

initList(head);

displayList(head);

printf("Input a integer to insert:");

scanf("%d",&x);

insertList(head,x);

printf("Processed list:");

displayList(head);

printf("Input a integer to delete:");

scanf("%d",&x);

deleteList(head,x);

printf("Processed list:");

displayList(head);

destoryList(head);

return 0;

}

运行结果姿昌：

‘柒’ C语言建立带头结点的单链表

单链表的生成有2种方式：头插法和尾插法。

1、头插法

/*********************************************************************
*函数名称：linklist*CreateLinklistHead()
*函数功能：利用头插法创建链表
*参数：无
*返回值：创建完链表后的链表头结点
*说明：无
*********************************************************************/
externlinklist*CreateLinklistHead()
{
	intx,i,nodeNum;
	linklist*head,*temp;//头结点与临时结点
	head=(linklist*)malloc(sizeof(linklist));//生成表头结点
	head->next=NULL;//给表头结点的指针域赋值
	printf("请输入链表中结点的个数：");
	scanf("%d",&nodeNum);
	for(i=1;i<=nodeNum;i++)
	{
		printf("请输入第%d个结点的数据裂兆：",i);
		scanf("%d",&x);
		temp=(linklist*)malloc(sizeof(linklist));//生成新的结点
		temp->data=x;//对新结点的数据域赋值
		//将新结点插到头结点之后
		temp->next=head->next;
		head->next=temp;
	}
	returnhead;//返回新建链表的头结点
}

2、尾插法

/*********************************************************************
*函数名称：linklist*CreateLinklistRear()
*函数功能：利用尾插法创建链表
*参数：无
*返回值：创建完链表后的链表头结点
*说明铅缺：无
*********************************************************************/
externlinklist*CreateLinklistRear()
{
	intx,i,nodeNum;
	linklist*head,*rear,*temp;//定义头结点、尾结点和临时结点
	head=(linklist*)malloc(sizeof(linklist));//生成表头结点，表头结点不存放数据
	head->next=NULL;//将表头结点的指针域赋值为NULL
	rear=head;//将表头结点赋值给表尾结点
	printf("请输入链表中结点的个数：");
	scanf("槐源辩%d",&nodeNum);
	for(i=1;i<=nodeNum;i++)
	{
		printf("请输入第%d个结点的数据：",i);
		scanf("%d",&x);
		temp=(linklist*)malloc(sizeof(linklist));//生成新的结点
		temp->data=x;//新增结点的数据域
		temp->next=NULL;//新增结点的指针域（由于是尾插法，所以插入的结点都在尾部，即指针域为NULL）
		rear->next=temp;//使前一个结点指向新增结点(head->next=temp)
		rear=temp;//将新增结点赋值给尾结点（尾插法，插入的结点在尾部）(rear=head->next)
	}
	//rear->next=NULL;//将尾结点的指针域赋值为空（为了方便检验链表是否为空链表）
	returnhead;//返回头结点
}

‘捌’ C语言创建单链表

s* creat_list()函数改下：
s* create_list()
{
int a[]={1,2,3,4,5},j=4;
s *h,*p,*current;
h=(s *)malloc(sizeof(s));
current = h; /*current指针用于跟随链表进度*/
h->next='侍橡\0';
while(j>=0)
{
p=(s *)malloc(sizeof(s));
p->i=a[j];
current->next=p;
current = p;
j--;

}
p ='\0';
current== '\0';
free(p);/*这里把氏谈谨用完的空歼基间释放掉，是个好习惯*/
free(current);
return h;
}

‘玖’ c语言用函数创建单链表

#include<stdio.h>
#include<stdlib.h>
//链表定义
typedef int ElemType;
typedef struct LNode
{
int data;
struct LNode *next;
}LNode,*LinkList;
/*************************************
* 链表函数 *
*************************************/
//链表初清运始化
void InitLink(LinkList &L);
//创建函数，尾插法
void CreateLink_T(LinkList &L,int n);
//创建函数，头插法
void CreateLink_H(LinkList &L,int n);
//销毁函数
void DestroyLink(LinkList &L);
//判断是否为空函数
bool EmptyLink(LinkList &L);
//获取函数
bool GetLink(LinkList &L,int i,int & e);
//答槐梁插入函数
void InsertLink(LinkList &L,int i,int e);
//删除函数
void DeleteLink(LinkList &L,int i,int &e);
//遍历函数
void TraverseLink(LinkList &L);
//链表长度函数
int LengthLink(LinkList &L);
//合并函数
void MergeLink(LinkList &L1,LinkList L2);
void main()
{
LinkList L1,L2;
InitLink(L1);
InitLink(L2);
CreateLink_H(L1,2);
CreateLink_T(L2,2);

TraverseLink(L1);
printf("\明帆n");
TraverseLink(L2);
printf("\n");

MergeLink(L1,L2);

TraverseLink(L1);
TraverseLink(L2);

}
//创建函数，尾插法
void InitLink(LinkList &L)
{
L=(LinkList)malloc(sizeof(LNode));
if (!L)
{
printf("Init error\n");
return;
}
L->next=NULL;
}
void CreateLink_T(LinkList &L,int n)
{
if(n<1)
{
printf("n must >=1\n");
return ;
}
else
{
// L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
for(int i=0;i<n;i++)
{
LinkList p=(LinkList)malloc(sizeof(LNode));// the lower letter p
printf("enter the data :\t");
scanf("%d",&(p->data));
p->next=L->next;
L->next=p;
}
}
}

//创建函数，头插法
void CreateLink_H(LinkList &L,int n)
{
if (n<1)
{
printf("n must >=1\n ");
return;
}
else
{
//L=(LinkList)malloc(sizeof(LNode));
LinkList pre=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
pre=L;
for(int i=0;i<n;i++)
{
LinkList p=(LinkList)malloc(sizeof(LNode));
printf("enter the data:\t");
scanf("%d",&(p->data));
pre->next=p;
pre=p;
}
pre->next=NULL;
}
}

//销毁函数
void DestroyLink(LinkList &L)
{
LinkList q=L,p=L;
while (p)
{
q=p;
p=p->next;
free(q);
}
L->next=NULL;

}

//判断是否为空函数
bool EmptyLink(LinkList &L)
{
if (NULL==L->next)
{
return true;
}
else
{
return false;
}
}

//获取函数
bool GetLink(LinkList &L,int i,int& e)
{
if (i<1)
{
return false;
}
else
{
if (EmptyLink(L))
{
return false;
}
LinkList p=L->next;
int j=1;
while(p&&j<i)
{
p=p->next;
j++;
}
if (!p||j>i)
{
return false;
}
else
{
e=p->data;
return true;
}

}
}

//插入函数
void InsertLink(LinkList &L,int i,int e)
{
if (i<0||i>LengthLink(L))
{
printf("Insert error\n");
return;
}
else
{
LinkList p=L;
int j=0;
while(p&&(j<i))
{
p=p->next;
j++;
}
if (!p||j>i)
{
printf("Insert error\n");
return;
}
else
{
LinkList q=(LinkList)malloc(sizeof(LNode));
q->data=e;
q->next=p->next;
p->next=q;

}
}

}

//删除函数
void DeleteLink(LinkList &L,int i,int &e)
{
if(i<=0||i>LengthLink(L))
{
printf("delete error\n");
return;
}
else
{
LinkList p=L;
int j=0;
while(p&&j<i-1)
{
p=p->next;
j++;
}
if(!p||j>i)
{
printf("please enter i again\n");
return;
}
else
{
LinkList q=p->next;
e=p->next->data;
p->next=p->next->next;
free(q);

}
}
}

//遍历函数
void TraverseLink(LinkList &L)
{
LinkList p=L->next;
if(!p)
{
printf("the Link L is empty\n");
}
while(p)
{
printf("%d\n",p->data);
p=p->next;
}
}
//链表长度函数
int LengthLink(LinkList &L)
{
int i=0;
LinkList p=L->next;
while(p)
{
p=p->next;
i++;
}
return i;
}

//合并函数
void MergeLink(LinkList &L1,LinkList L2)
{
int i=0,flag=0;
LinkList p1=L1->next,p2=L2->next;
LinkList p=(LinkList)malloc ((LengthLink(L1)+LengthLink(L2)+2)*sizeof(LNode));

LinkList pre=p;
if (!p)
{
printf("MergeLink error\n");
return;
}
p->next=NULL;
while (p1&&p2)
{
if (p1->data>=p2->data)
{
InsertLink(p,i++,p2->data);
p2=p2->next;
}
else
{
InsertLink(p,i++,p1->data);
p1=p1->next;
}
}
while (p1)
{
InsertLink(p,i++,p1->data);
p1=p1->next;
}
while(p2)

{
InsertLink(p,i++,p2->data);
p2=p2->next;
}
while(pre)
{
pre=pre->next;
}

LinkList q=L1;
L1=p;
DestroyLink(q);
DestroyLink(L2);

}

‘拾’ 建立单链表 用C语言方式

首先，你真的确定你知道什么是链表，什么是顺序表？好了，算了就按题中的顺序表来写喽（不过，我真的建议你，如果你真不清楚，请把它弄清楚，返塌闭ok?）程序代码：（看上去有点多，其实算法很简单的）#include<stdlib.h>
#include<stdio.h>
#include<conio.h>#define LIST_INT_SIZE 1000
#define ERROR 0
#define OK 1typedef struct {
int *elem;
int length;
int listsize;
}ListSq;typedef int Status;Status Initlist_sq(ListSq *l){
//初始化顺序表
l->elem=(int *)malloc(LIST_INT_SIZE*sizeof(int));
if(!l->elem) exit(ERROR);
l->length =0;
l->listsize=LIST_INT_SIZE;
return OK;
}Status InputList_sq(ListSq *l,int length){
//对顺序表进行输入，输入的长度为：length
//length的区间为[1,1000]
int i;
if(length >1000 ||length<1) exit(ERROR);
printf("please input the data:\n");
for(i=0;i<length;i++){
scanf("%d",l->elem+i);
l->length++;
}
return OK;
}Status OutputList_sq(ListSq *l){
//把顺序表输出
int *p;
for(p=l->elem;p<=&(l->elem[l->length-1]);p++)
printf("%d ",*p);
return OK;
}Status ListDelete_sq(ListSq *l,int i){
//删除顺序表中漏裂位序为i的元素
//注意i的取值范围！
int *p,*pe;
if(i<1 || i>1000) exit(ERROR);
p=&(l->elem[i+1]);
pe=&(l->elem[l->length-1]);
while(p<=pe){
*(p-1)=*p;
p++;
}
l->length--;
return OK;
}Status ConvertList_sq(ListSq *l){
//这个操作就是执行衫穗你题目要求的那玩意
int i,j,k;
for(i=0;i<l->length;i++){
k=i;
for(j=0;j<i;j++)
if(l->elem[i]==l->elem[j])
ListDelete_sq(l,i);
}
return OK;
}
int main(void)
{
ListSq list;
int length,status;
printf("Creat a new SQlist:\n");
status=Initlist_sq(&list);
if(!status)
{
printf("\aWarning:Failed to Creat the List\n");
getch();
exit(ERROR);
}
else {
printf("succeed to creat!\n");
printf("******** status of the list *********\n");
printf("the length is %d\nthe listsize is %d\n",list.length,list.listsize);
}
printf("Now you could input the data for the list:\n");
printf("How many datas do you want to input:");scanf("%d",&length);
InputList_sq(&list,length);
OutputList_sq(&list);
printf("\nthe result of converting list:");
ConvertList_sq(&list);
OutputList_sq(&list);
putchar('\n');
return 0;
}一下是运行结果： 好了，完成任务了。。。算法不难，认真思考就搞定，望楼主坚持下去，不断努力！
对了，要是程序上有什么不懂得，hi我就可以了