c语言链式结构

❶ c语言数据结构题目（链式结构）

#include"stdio.h"
#include"conio.h"
#include"stdlib.h"
#defineNULL0

typedefstructNode
{
	intdata;
	structNode*next;
}Node,*linklist;

Node*initlist();
voidcreatelist(Node*head,intn);
voiddisplay(Node*head);
voidinsert(Node*head,intx,inti);

voidmain()
{
	Node*head;
	intn,x,i,k;
	head=initlist();
	printf("n=");scanf("%d",&n);

	createlist(head,n);
	display(head);

	printf("i=");scanf("%d",&i);
	printf("x=");scanf("%d",&x);
	insert(head,x,i);
	display(head);
	
}

Node*initlist()
{
	Node*head;
	head=(linklist)malloc(sizeof(Node));
	head->next=NULL;
	return(head);
}

voidcreatelist(Node*head,intn)
{
	inti;
	Node*p,*s;
	p=head;
	for(i=1;i<=n;i++)
	{
		s=(linklist)malloc(sizeof(Node));
		scanf("%d",&s->data);//加个取地址符号
		s->next=NULL;
		p->next=s;
		p=s;
	}
}

voiddisplay(Node*head)
{
	Node*p;
	p=head->next;
	for(;p!=NULL;)
	{
		printf("%3d",p->data);
		p=p->next;
	}
}

voidinsert(Node*head,intx,inti)
{
	Node*p,*s;
	intj=0;
	p=head;
	while((p!=NULL)&&(j<i-1))//是i
	{
		p=p->next;
		j++;
	}
	s=(Node*)malloc(sizeof(Node));
	s->data=x;
	s->next=p->next;
	p->next=s;
}
//很好，就是一个小错误！还有疑问的话就追问！

❷ 关于C语言 数据结构中链式结构的问题

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
typedef struct Dian
{
int data;
struct Dian * pnext;
}DIAN,*PDIAN;
void show(PDIAN head)
{
PDIAN p=head->pnext;
while (p)
{
printf("%d ",p->data);
p=p->pnext;
}
}
PDIAN creat_list();
//void traverse_list(PDIAN pHead);
void add_list(PDIAN phead,int val);
void main()
{
PDIAN phead=NULL;
phead=creat_list();
add_list(phead,5);
show(phead);
//traverse_list(phead);
}
PDIAN creat_list()
{
PDIAN phead=(PDIAN)malloc(sizeof(DIAN));
if(phead==NULL)
{
printf("分配内存失败，程序关闭！\n");
exit(-1);
}
PDIAN pend=(PDIAN)malloc(sizeof(DIAN));
printf("请输入添加数据:");
scanf("%d",&pend->data);
phead->pnext=pend;
pend->pnext=NULL;
return phead;
}
//往链表中添加元素
void add_list(PDIAN phead,int val)
{
PDIAN p=phead;
while(p->pnext!=NULL)
{
p=p->pnext;
}
PDIAN pnew=(PDIAN)malloc(sizeof(DIAN));
if(pnew == NULL)
{
printf("分配内存失败，程序关闭！\n");
exit(-1);
}
pnew->data=val;
p->pnext=pnew;
pnew->pnext=NULL;
}

❸ c语言链表结构体问题

结构体定义指针应该是这样的： node *p;或者struct Node *p;
在定义/声明函数时，void as(struct node *p);这样是不对的。应该是这样：
void as(struct Node *p);
或者
void as(node *p);
函数调用的时候不用指针直接放入结构体该是这样调用的：
node stnod;
as(&stnod);
它和
node stnod,*p_stnod;
p_stnod=&stnod;
as(p_stnod);
作用是一样的。

❹ 用C语言实现定义线性表的链式存储结构

#include<stdio.h>
#include<malloc.h>
typedef struct{
int *elem;
int length;
int listsize;}sqlist;

int init_List(sqlist &L){
L.elem=(int*)malloc(100*sizeof(int));
if(!L.elem) return 0;
else
L.length=0;
L.listsize=100;return 1;}

void main(){
sqlist l;
int *p;int a;int e;int b;
int i;
if(!init_List(l)) printf("内存分配失败");
else
p=l.elem;
printf("输入线性表的长度l.length的值:\n");
scanf("%d",&l.length);
printf("输入%d个数:\n",l.length);
for(i=0;i<l.length;i++)
scanf("%d",p++);
printf("创建的线性表为:\n");
for(i=0;i<l.length;i++)
printf("%d\n",l.elem[i]);｝

❺ c语言线性表链式结构中如何存储数据

对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem;

对于LinkList *L:L是指向定义的Node结构体指针的指针,所以(*L)是指向Node结构体的指针,可以用->运算符来访问结构体成员,即(*L)->elem,当然,(**L)就是Node型结构体了,所以可以用点运算符来访问结构体成员,即(**L).elem;

在链表操作中,我们常常要用链表变量作物函数的参数,这时,用LinkList L还是LinkList *L就很值得考虑深究了,一个用不好,函数就会出现逻辑错误,其准则是:
如果函数会改变指针L的值,而你希望函数结束调用后保存L的值,那你就要用LinkList *L,这样,向函数传递的就是指针的地址,结束调用后,自然就可以去改变指针的值;
而如果函数只会修改指针所指向的内容,而不会更改指针的值,那么用LinkList L就行了

❻ C语言二级考试循环链表是循环队列的链式存储结构

循环队列本身是一种顺序存储结构，而循环列表是一种链式存储结构。两者之间是平级关系。

线性链表是线性表的链式存储结构，包括单链表，双链表，循环链表等。

队列的顺序存储结构一般采用循环队列的形式。

循环队列的操作是按数组取摸运算的，所以是顺序存储，而循环链表本身就是收尾相连的，所以循环链表不是循环队列，两种不同的存储结构，虽然实现的功能是一样的，实现循环两种方式 顺序存储就是循环队列，链式存储就是循环链表。

(6)c语言链式结构扩展阅读：

1、比顺序存储结构的存储密度小(链式存储结构中每个结点都由数据域与指针域两部分组成，相比顺序存储结构增加了存储空间)。

2、逻辑上相邻的节点物理上不必相邻。

3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。

4、查找节点时链式存储要比顺序存储慢。

5、每个节点是由数据域和指针域组成。

6、由于簇是随机分配的，这也使数据删除后覆盖几率降低，恢复可能提高。

❼ c语言问题，什么是无序线性表什么是链式存储结构

这是数据结构问题，无序线性表顾名思义就是里面的元素是无序的一张线性表，就像数组，就是一种线性表，至于线性表的具体知识，建议自己去看一下数据结构，这样更明白。
链式存储结构跟线性存储结构相对应。线性存储结构是在连续的空间中存储，可以实现顺序的查找，链式存储则可以实现在不连续的空间访问存储，使用指针就能实现了。
这两个概念不是C语言问题，这是数据结构的知识，这是很重要的，建议你认真的学习下数据结构就明白了，这两个概念是最基础的概念！

❽ c语言怎么利用 顺序或链式结构实现中序线索化二叉树

线索化二叉树实质就是将二叉树中的空指针改成指向前驱后者后继的指针 从而确定二叉树的唯一性

而前驱后后继只能在遍历中才能确定 所以要对二叉树进行中序遍历的过程中进行线索化

中序线索化二叉树源码

#include "stdio.h"
#include "stdlib.h"
typedef enum piontertag{link,thread};
typedef struct bithrnode
{char data;
piontertag ltag,rtag;
struct bithrnode *lchild,*rchild;
}BithrNODE;
BithrNODE *BithrCreat();//先序递归建立二叉树
BithrNODE *InOrderThreading(BithrNODE *);//中序线索化二叉树
void InThreading(BithrNODE *);//中序遍历过程中线索化二叉树的具体过程
void InOrderTraverse(BithrNODE *);//中序线索化二叉树输出
BithrNODE *pre;
int main(void)
{
BithrNODE *a=BithrCreat();
a=InOrderThreading(a);
InOrderTraverse(a);
return 0;
}
BithrNODE *BithrCreat()
{
char x;
BithrNODE *p=NULL;
scanf("%c%*c",&x);
if(x=='#')
return NULL;
p=(BithrNODE *)malloc(sizeof(BithrNODE));
p->data=x;
p->ltag=p->rtag=link;
p->lchild=BithrCreat();
p->rchild=BithrCreat();
return p;
}
BithrNODE *InOrderThreading(BithrNODE *a)
{
BithrNODE *h=(BithrNODE *)malloc(sizeof(BithrNODE ));
if(!h)
exit(-1);
h->ltag=link;
h->rtag=thread;
h->rchild=h;
if(!a) h->lchild=h;
else
{
h->lchild=a;
pre=h;
InThreading(a);
pre->rtag=thread;
pre->rchild=h;
h->rchild=pre;
}
return h;
}
void InOrderTraverse(BithrNODE *a)
{
BithrNODE *p=a->lchild;
while(p!=a)
{
while(p->ltag==link)
p=p->lchild;
printf("%c ",p->data);
while(p->rtag==thread&&p->rchild!=a)
{
p=p->rchild;
printf("%c ",p->data);
}
p=p->rchild;
}
}
void InThreading(BithrNODE *a)
{
if(a)
{
InThreading(a->lchild);
if(!a->lchild)
{
a->ltag=thread;
a->lchild=pre;
}
if(!pre->rchild)
{
pre->rtag=thread;
pre->rchild=a;
}
pre=a;
InThreading(a->rchild);
}
}

❾ 用C语言写通讯录，用链式结构，包含删除，查找，插入，显示功能

# include<stdio.h>
# include<string.h>
struct tongxun
{char name[20];
char number[20];
struct tongxun *next;
};
int all=0;
struct tongxun* tj() /*创建链表并添加成员*//**/
{
struct tongxun *head=NULL;
struct tongxun *p,*q;
system("CLS");

p=q=(struct tongxun *)malloc(sizeof(struct tongxun));

for(;;)
{printf("请输入姓名：（如果输入0则退出添加）\n");
scanf("%s",p->name);
if(!(strcmp(p->name,"0"))){ free(p);return head;}
else {printf("请输入电话号码：\n");
scanf("%s",p->number);
all++;
if(all==1)
{p->next=head;
q=p;
head=q;}
else
{p->next=NULL;
q->next=p;
q=p;
}
p=(struct tongxun *)malloc(sizeof(struct tongxun));
}
}
}
cz(struct tongxun *head) /*查找函数*/
{char name1[20],*a;
struct tongxun *p;
p=head;a=name1;
system("CLS");
printf("请输入要查找的姓名：\n");
scanf("%s",a);
while(p!=NULL)
{if((strcmp(p->name,a))==0) {printf("姓名：%s\n电话号码：%s\n",p->name,p->number);return;}
else p=p->next;
}
printf("没有此人\n");
return;
}

insert(struct tongxun *head) /*插入新成员*/
{struct tongxun* pnew;
pnew=(struct tongxun *)malloc(sizeof(struct tongxun));
while(1)
{printf("请输入姓名：（如果输入0则退出添加）\n");
scanf("%s",pnew->name);
if(!(strcmp(pnew->name,"0"))){ free(pnew);return head;}
else {printf("请输入电话号码：\n");
scanf("%s",pnew->number);
all++;
pnew->next=head;
head=pnew;
pnew=(struct tongxun *)malloc(sizeof(struct tongxun));
}
}
}
shuchu(struct tongxun *head) /*输出成员*/
{struct tongxun *p;
p=head;
printf("这里一共有%d个成员\n",all);
while(p!=NULL)
{printf("姓名：%s\n电话号码：%s\n",p->name,p->number);
p=p->next;
}
}
xg(struct tongxun *head) /*修改成员*/
{char name1[20],*a;
struct tongxun *p;
p=head;a=name1;
system("CLS");
printf("请输入要修改的姓名：\n");
scanf("%s",a);
while(p!=NULL)
{if((strcmp(p->name,a))==0) {printf("请重新输入姓名：\n");
scanf("%s",p->name);
printf("请重新输入电话号码：\n");
scanf("%s",p->number);return;}
else p=p->next;
}
printf("没有此人\n");
return;

}
sc(struct tongxun *head) /*删除成员*/
{char name1[20],*a;
struct tongxun *p,*q;
p=q=head;a=name1;
system("CLS");
printf("请输入要删除的姓名：\n");
scanf("%s",a);
while(p!=NULL)
{
if((strcmp(p->name,a))==0) {all--;q->next=p->next;return;}
else {q=p;p=p->next;}
}
printf("没有此人\n");
return;

}
void main()
{struct tongxun *head;int i;
while(1)
{printf("请选择：\n");
printf("1.添加 2.查找 3.修改 4.删除 5.插入 6.输出\n");scanf("%d",&i);
switch(i)
{case 1:head=tj();break;
case 2:cz(head);break;
case 3:xg(head);break;
case 4:sc(head);break;
case 5:insert(head);break;
case 6:shuchu(head);break;
default:printf("输入有误，请重新输入：\n");break;
}
}
}