单链表的初始化函数c语言,C语言单链表定义
关于C语言数据结构单链表初始化的问题
其实这是一个与C语言参数传值的问题，C语言规定实参变量对形参变量的参数传递是值传递，在执行函数调用时形参变量值的改变，并不影响主调函数的实参变量。
创新互联是一家专注于网站设计制作、成都网站制作与策划设计,安溪网站建设哪家好?创新互联做网站,专注于网站建设十年,网设计领域的专业建站公司;建站业务涵盖:安溪等地区。安溪做网站价格咨询:18982081108
如：int x,y;
void fun(int a, int b)
{
b=b+a;
}
void main()
{ x=1; y=2;
fun(x, y);
.....
//此时仍然x=1; y=2;
}
但是，函数写成如下形式
void InitList(LinkList *head)；可以实现引用传递参数的功能。
在需要函数内部修改链表头指针时，用该形式可以解决该问题。
而void InitList(LinkList head) 不可以在函数内部修改链表头指针。
c语言用函数创建单链表
#includestdio.h
#includestdlib.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(n1)
{
printf("n must =1\n");
return ;
}
else
{
// L=(LinkList)malloc(sizeof(LNode));
L-next=NULL;
for(int i=0;in;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 (n1)
{
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;in;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 (i1)
{
return false;
}
else
{
if (EmptyLink(L))
{
return false;
}
LinkList p=L-next;
int j=1;
while(pji)
{
p=p-next;
j++;
}
if (!p||ji)
{
return false;
}
else
{
e=p-data;
return true;
}
}
}
//插入函数
void InsertLink(LinkList L,int i,int e)
{
if (i0||iLengthLink(L))
{
printf("Insert error\n");
return;
}
else
{
LinkList p=L;
int j=0;
while(p(ji))
{
p=p-next;
j++;
}
if (!p||ji)
{
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||iLengthLink(L))
{
printf("delete error\n");
return;
}
else
{
LinkList p=L;
int j=0;
while(pji-1)
{
p=p-next;
j++;
}
if(!p||ji)
{
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 (p1p2)
{
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语言数据结构单链表初始化
你说的那个是逆序建立n个节点的链表，建完头结点后由于链表中没有其他节点就把头结点的next置为空，这一点如果不明白的话去看链表那一章，有介绍！！！
之后从后往前建立链表！！刚开始是L-next =NULL
要注意p是每次新建的节点，这样从后往前以此建立链表，只要明白p是每次新建的节点，和从后往前建立，就会明白的！！给你花了张图！！
C语言初始化单链表！
在单
链表
A中删除所有和
单链表
B中元素相同的结点
#include
"stdafx.h"
#include
stdio.h
#include
malloc.h
#define
SIZE
sizeof(struct
node)
struct
node{
int
data;
struct
node
*next;
};
void
init(struct
node
*LC){
int
n;
struct
node
*Str,*p;
p=(struct
node
*)malloc(SIZE);
Str=LC;
printf("请输入链表A,以小于零的数结束输入:\n");
scanf("%d",n);
while(n=0){
p-data=n;
Str-next=p;
Str=p;
p=(struct
node
*)malloc(SIZE);
scanf("%d",n);
Str-next=NULL;
}
printf("您输入的序列的是:\n");
for
(Str=LC-next;Str!=NULL;){
printf("%d
",Str-data);
Str=Str-next;
}
printf("\n");
}
void
delet_LA(struct
node
*LA,struct
node
*pa){
struct
node
*p;
struct
node
*q;
p=LA;
q=p;
for
(p;p!=pa;){
q=p;
p=p-next;
}
q-next=pa-next;
}
void
delete_same(struct
node
*LA,struct
node
*LB){
struct
node
*pa,*pb;
pa=LA-next;
pb=LB-next;
for
(pb;pb!=NULL;){
for
(pa;pa!=NULL;){
if
(pb-data==pa-data){
delet_LA(LA,pa);
pa=LA-next;
}
else{
pa=pa-next;
}
}
pb=pb-next;
pa=LA-next;
}
printf("处理后的单链表A为:\n");
for
(pa=LA-next;pa!=NULL;){
printf("%d
",pa-data);
pa=pa-next;
}
}
void
main(){
struct
node
*LA;
struct
node
*LB;
LA=(struct
node
*)malloc(SIZE);
if(LA!=NULL)
LA-data=-1;
LB=(struct
node
*)malloc(SIZE);
if(LB!=NULL)
LB-data=-1;
init(LA);
init(LB);
delete_same(LA,LB);
}
网页名称：单链表的初始化函数c语言,C语言单链表定义
网页链接：http://cdiso.cn/article/hescpg.html
