c语言链式存储结构
你的函数stacknotempty有问题，返袭绝衫回的值拍腔与字面意思反了，宏哪一般栈操作习惯用stackEmpty来做判断，你在stacknotempty中，堆栈为空却返回了1。
㈡ C语言求救~~顺式存储和链式存储结构区别
链式存储结构的存让返告储空间在逻辑上是连续的，但是在物理上是离散的；而顺序存储结构的存储空间在逻辑上是连续的，在物理上也是连续的。所以链式存储结构可以将一些零碎的小空间链接起来组成逻辑上连续的空间，因此空间利用率较高；而顺序存储结世纯构是占用磁盘上一片连续的物理空间坦明，小于存储要求的那些空间不能被使用，因此会跳过那些小存储空间，然后寻找满足要求的连续存储空间，于是空间利用率就变低了。 但是存储相同内容，顺序存储结构比链式存储结构节省存储空间。
㈢ 链式存储队列的数据结构（逻辑结构+存储结构）分析、链式存储队列的基本C语言结构体分析与定义
链式队列
链式存储结构的队列称作链式队列。
链式队列的队头指针指在队列的当前队头结点位置，队尾指针指在队列的当前队尾结点位置。不带头结点的链式队列时可直接删除队头指针所指的结点。
链式队列中结点的结构体可定义如下：
typedef struct qnode
{
DataType datal;
Struct qnode *next;
}LQNode;
为了方便参数调用，通常把链式队列的队头指针front和队尾指针rear也定义为如下的结构体类型LQueue：
typedef struct
{
LQNode *front;
LQNode *rear;
}LQueue;
链式队列操作的实现
（1） 初始化QueueInitiate(LQueue *Q)
void QueueInitiate(LQueue *Q)
{
Q->rear=NULL;
Q->front=NULL;
}
(2)非空否QueueNotEmpty(LQueue Q)
int QueueNotEmpty(LQueue Q)
/*判断链式队列Q非空否，非空返回1，否则返回0*/
{
if(Q.front==NULL)return 0;
else return 1;
}
(3)入队列QueueAppend(LQueue *Q,DataType x)
int QueueAppend(LQueue *Q,DataType x)
/*把数据元素x插入链式队列Q队列的队尾，入队列成功返回1，否则返回0*/
{
LQNode *p;
if((p=(LQNode*)malloc(sizeof(LQNode)))==NULL)
{
printf(“内存不足无法插入!\n);
return 0;
}
p->data=x;
p->next=NULL;
if(Q->rear!=NULL)Q->rear->next=p;
Q->rear=p;
if(Q->front==NULL)Q->front=p;
return 1;
}
(4)出队列QueueDelete(LQueue *Q,DataType *d)
int QueueDelete(LQueue *Q,DataType *d)
/*删除链式队列Q的队头数据元素值到d，出队列成功返回1，否则返回0*/
{
LQNode *p;
if(Q->front==NULL)
{
printf(“队列已空无数据元素出队列!\n”);
return 0;
}
else
{
*d=Q->front->data;
p=Q->front;
Q->front=Q->front->next;
if(Q->front==NULL)Q->rear=NULL;
free(p);
return 1;
}
}
(5)取队头数据元素QueueGet(LQueue *Q,DataType *d)
int QueueGet(LQueue *Q,DataType *d)
/*取链式队列Q的当前队头数据元素值到d，成功返回1，否则返回0*/
{
if(Q.front==NULL)
{
printf(“队列已空无数据元素出队列!\n);
return 0;
}
else
{
*d=Q.front->data;
return 1;
}
}
(6)撤销动态申请空间Destory(LQueue *head)
int Destory(LQueue *head)
{
LQNode *p,*p1;
p=Q.front;
while(p!=NULL)
{
p1=p;
p=p->next;
free(p1);
}
}
帮你转的，我觉得他描述的很清楚。希望对你有帮助。
㈣ 分别写出线性表的链式存储结构、二叉树的二叉链表存储机构的类C语言描述
线性表的链式存储结构：
typedef int ElemType;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
(被封装好的每个节点，都有一个数据域data和一个指针域*next用于指向下一个节点)
二叉树的二叉链表：
typedef int TElemType;
typedef struct BiTNode
{
TElemType data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
(被封装好的每个节点，都有一个数据域data和两个指针域 *lchild,*rchild分别指向左右子树)
需要什么类型的数据作为数据域可更改，或者typedef int ElemType;和typedef int TElemType;中的int，比如改为char、float等或者自定义数据类型。
㈤ 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语言基础知识中：线性表的顺序、链式存储结构分别是：随机存取和顺序存取结构对吗
不对，数组是随机存取，所有的线性表都是顺序存取结构。你想想，我要找第5个元素，用数组直接 A[4] 就找到了，而线性表就要从“头”元素开始一个一个地往后遍历，直到需要的那个，随机不了。
㈦ 如何用C语言实现简单的链式存储结构
使用结构体：
typedef struct node{
int data;
struct node* next;
}Node;
就可以实现，以上是一个单链表的节点元素乱启，李清每个节点的next指向下一个节点，就可以实现链式存储了。遇到其他类似的问题，可以根据需要设置相应哪陪前的指针域。
㈧ 用C语言编写链式存储结构下实现线性表的创建,插入,删除,按值查找
#include <stdio.h>
#include <stdlib.h>
typedef struct LNode{
int data; //链表数据
struct LNode* next; //链表指针
}LNode,*LinkList;
/*头插法-建立单链表*/
LinkList HeadCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode)); //建立头结点
la->next=NULL;
scanf("%d",&num);
while(num!=10)
{
LNode *p=(LinkList)malloc(sizeof(LNode));
p->data=num;
p->next=la->next;
la->next=p;
scanf("%d",&num);
}
return la;
}
/*尾插法-建立单链表*/
LinkList TailCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode));
la->next=NULL;
LinkList s,r=la;
scanf("%d",&num);
while(num!=10)
{
s=(LinkList)malloc(sizeof(LNode));
s->data=num;
r->next=s;
r=s;
scanf("%d",num);
}
r->next=NULL;
return la;
}
/*单链表遍历*/
void TravelList(LinkList la)
{
LinkList p=la->next;
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("\n");
}
/*单链表的按位查找*/
LinkList GetElem(LinkList la,int i)
{
int j=1;
LNode* p=la->next;
if(i<1)
return NULL;
while(p && j<i)
{
p=p->next;
j++;
}
return p;
}
/*单链表的按值查找*/
LinkList LocalElem(LinkList la,int e)
{
LNode* p=la->next;
while(p!=NULL && p->data!=e)
p=p->next;
return p;
}
/*单链表插入操作*/
bool InsertList(LinkList la,int i,int e)
{
//在la链表中的i位置插入数值e
int j=1;
LinkList p=la,s;
while(p && j<i)
{
p=p->next;
j++;
}
if(p==NULL)
return false;
if((s=(LinkList)malloc(sizeof(LNode)))==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
/*单链表删除操作*/
bool DeleteList(LinkList la,int i)
{
int j=1;
LinkList p=la,q;
while(p && j<i) //p指向第i-1个元素
{
p=p->next;
j++;
}
if(p==NULL || p->next==NULL) //表示不存在第i-1个和第i的元素
return false;
q=p->next;
p->next=q->next;
free(q);
return true;
}
/*单链表的表长*/
int LengthList(LinkList la)
{
int nLen=0;
LinkList p=la->next;
while(p)
{
p=p->next;
nLen++;
}
return nLen;
}
/*单链表逆置*/
LinkList Reserve(LinkList la)
{
if(la==NULL || la->next==NULL)
return la;
LinkList p=la->next,q=p->next,r=q->next;
la->next=NULL;
p->next=NULL;
while(r!=NULL)
{
q->next=p;
p=q;
q=r;
r=r->next;
}
q->next=p;
la->next=q;
return la;
}
int main()
{
LNode la;
LinkList p;
p=HeadCreate(&la); //头插法创建单链表
TravelList(p);
printf("%p\n",GetElem(p,1)); //获得第1个结点地址
InsertList(p,2,10); //在链表的第2个位置插入元素10
TravelList(p);
DeleteList(p,3); //删除链表的第3个元素
TravelList(p);
printf("%d\n",LengthList(p)); //获得链表长度
p=Reserve(p);
TravelList(p);
return 0;
}
//运行结果
//5 6 12 7 8 14 9 3 2 5 14 10 头插法创建链表
//14->5->2->3->9->14->8->7->12->6->5-> 显示链表
//00382490 第一个结点的地址
//14->10->5->2->3->9->14->8->7->12->6->5-> 插入元素值为10的结点
//14->10->2->3->9->14->8->7->12->6->5-> 删除第三个结点
//11 获得链表长度
//5->6->12->7->8->14->9->3->2->10->14-> 链表逆置
//Press any key to continue
这是我写的一个线性表链式存储的综合程序，包含了你所要的创建、删除、插入、按值查找的功能，还有一些额外的功能。下面加注释的是程序运行结果，你可以参考试着改改程序，让程序更加完美。希望对你有帮助，呵呵！
㈨ c语言问题，什么是无序线性表什么是链式存储结构
这是数据结构问题，无序线性表顾名思义就是里面的元素是无序的一张线性表，就像数组，就是一种线性表，至于线性表的具体知识，建议自己去看一下数据结构，这样更明白。
链式存储结构跟线性存储结构相对应。线性存储结构是在连续的空间中存储，可以实现顺序的查找，链式存储则可以实现在不连续的空间访问存储，使用指针就能实现了。
这两个概念不是C语言问题，这是数据结构的知识，这是很重要的，建议你认真的学习下数据结构就明白了，这两个概念是最基础的概念！
㈩ 求用链式存储结构写的学生信息管理系统，c语言
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct student
{
int id;
int csn;
int csy;
char name[10];
} STU;
typedef struct node
{
STU date;
struct node *next;
}NODE;
void chushihualink(NODE *H)
{
H->next=NULL;
}
void xinzenglink(NODE *H,NODE *newstu)
{
while(H->next)
H=H->next;
H->next=newstu;
newstu->next=NULL;
}
void charulink(NODE *H,NODE *newstu,int pos)
{
int i;
for(i=0;i<pos;i++)
H=H->next;
newstu->next=H->next;
H->next=newstu;
}
void shuchulink(NODE *H)
{
while(H->next)
{
printf("姓名%s，学号%d，出生年月%d,%d\郑启穗n",H->next->date.name,H->next->date.id,H->next->date.csn,H->next->date.csy);
H=H->next;
}
}
void xiugailink(NODE *H,NODE *oldstu,NODE *newstu)
{
while(H->next)
{
if(H->next->date.id==oldstu->date.id)
{
oldstu->date=newstu->date;
newstu->next=oldstu->next;
break;
}
H=H->next;
}
}
void shanchulink(NODE *H,NODE *oldstu)
{
while(H->next)
{
if(H->next->date.id==oldstu->date.id)
{
H->next=H->旁庆next->next;
break;
}
H=H->next;
}
}
NODE paixulink(NODE *H)
{
NODE *p,*q;
STU temp;
for(p=H;p->next!=NULL;p=p->next)
{
for(q=p->next;q->next!=NULL;q=q->next)
{
if(p->next->date.id>q->next->date.id)
{
temp=p->next->date;
p->next->date=q->next->date;
q->next->date=temp;
}
}
}
return *H;
}
int main() {
NODE *H;
NODE newstu1;
NODE newstu2;
NODE newstu3;
NODE newstu4;
NODE newstu5;
H=(NODE *)malloc(sizeof(NODE));
newstu1.date.id=101;
newstu1.date.csn=1997;
newstu1.date.csy=10;
newstu1.next=NULL;
strcpy(newstu1.date.name,"zhangsan");
newstu2.date.id=102;
newstu2.date.csn=1995;
newstu2.date.csy=12;
newstu2.next=NULL;
strcpy(newstu2.date.name,"lisi");
newstu3.date.id=103;
newstu3.date.csn=1999;
newstu3.date.csy=5;
newstu3.next=NULL;
strcpy(newstu3.date.name,"wangwu");
newstu4.date.id=104;
newstu4.date.csn=1994;
newstu4.date.csy=4;
newstu4.next=NULL;
strcpy(newstu4.date.name,"zhaoliu");
newstu5.date.id=105;
newstu5.date.csn=1991;
newstu5.date.csy=5;
newstu5.next=NULL;
strcpy(newstu5.date.name,"喊卜tianqi");
chushihualink(H);
xinzenglink(H,&newstu1);
xinzenglink(H,&newstu2);
xinzenglink(H,&newstu3);
charulink(H,&newstu4,2);
xiugailink(H,&newstu2,&newstu5);
paixulink(H);
shanchulink(H,&newstu5);
shuchulink(H);
}