‘壹’ c语言基础知识中：线性表的顺序、链式存储结构分别是：随机存取和顺序存取结构对吗
不对，数组是随机存取，所有的线性表都是顺序存取结构。你想想，我要找第5个元素，用数组直接 A[4] 就找到了，而线性表就要从“头”元素开始一个一个地往后遍历，直到需要的那个，随机不了。
‘贰’ 编一个程序实现线性表的顺序存储和链式存储
以下是用C语言实现的线性表的链式存储的代码，顺序存储很简单只要定义一个结构体，然后顺序读入就可以了
/*
* 头结点存储数据，即不带头结点的链表
*/
#include <stdio.h>
#include <stdlib.h>
#define OverFlow -1 //定义OverFlow表示内存溢出
#define OK 0 //定义OK表示成功
#define Error -2 //定义操作失败的返回值
#define OverFlow -1; //定义OverFlow表示内存溢出
#define OK 0; //定义OK表示成功
#define Error -2; //定义操作失败的返回值
/*
* 首先定义一个数据类型int的别名ElemType，
* 增强程序的可移植性，注意typedef和define的区别
*/
typedef int ElemType;
/*
* 紧接着定义链表的节点，其实就是>=1个包含数据
* 的元素（类型任意）和一个本结构体类型的Next指
* 针（其值指向链表的下一个节点的地址）
*/
typedef struct node
{
ElemType data;
struct node *next;
} Node, *LinkList;
/*
* 1.构建头结点不存储数据的空表（相对简单）
* 注意函数参数传递的原理
*/
void Init_LinkList(LinkList *Head_pointer)
{
*Head_pointer = NULL;
}
/*
* 2.插入一个元素（头插）
* 这时候不需要传入位置的数据，只需要传入头指针和数据
*/
int Insert_First(LinkList *Head_pointer, ElemType x)
{
Node *p; //这里考虑为什么不用LinkList
p = (Node *) malloc(sizeof Node);
if (p == NULL)
return OverFlow;
p->data = x;
p->next = *Head_pointer;
*Head_pointer = p;
return OK;
}
/*
* 3.查找指定元素，注意这里用到了LinkList定义数据
* 因为不是要定义一个节点，只是定义一个指针
*/
LinkList Location_LinkList(LinkList Head, ElemType x)
{
LinkList p;
p = Head;
while(p != NULL)
{
if (p->data == x)
break;
p = p->next;
}
return p;
}
/*
* 4.删除指定的元素
* 有可能改变头结点的值，所以要传入指针
* 对头结点就是要删除的元素进行单独处理
*/
int Delete_LinkList(LinkList *Head_pointer, ElemType x)
{
Node *p, *q;
p = *Head_pointer;
if (p->data == x)//考虑头结点就是要删除的元素
{
*Head_pointer = (*Head_pointer)->next;
free(p);
return OK;
}
else
{
q = p; p = p->next; //q指向前一个节点，p指向下一个节点
while(p != NULL)
{
if (p->data == x)
{
q->next = p->next;
free(p);
return OK;
}
q = p; p = p->next;
}
}
return Error;
}
/*
* 5.遍历线性表，打印每个数据
* 只需要传入Head的值即可
* 头结点为空需要打印空表，在linux的超级终端下注意中文编码问题
*/
void Show_LinkList(LinkList Head)
{
LinkList p = Head;
int i = 0;
printf("----链表打印----\n");
if (p == NULL) //处理头结点为空的情况
printf("空表\n");
while (p != NULL)
{
printf("[%d]:%d\t", i++, p->data);
p = p->next;
}
}
/*
* 6.清空链表
* 清除到头结点为空的状态，也就是一个空表的状态
*/
void SetNull_LinkList(LinkList *Head_pointer)
{
LinkList p, q;
p = *Head_pointer;
while (p != NULL)
{
q = p;
p = p->next;
free(q);
}
}
/*
*8.调用单链表操作的主函数
*/
int main(void)
{
LinkList Head;
int i;
Node *loca;
ElemType x;
Init_LinkList(&Head);
do
{
printf("\n");
printf("1---插入一个元素（Insert）\n");
printf("2---查询一个元素（Locate）\n");
printf("3---删除一个元素（Delete）\n");
printf("4---显示所有元素（Show）\n");
printf("5---计算表的长度（Length）\n");
printf("6---退出\n");
scanf("%d", &i);
switch (i)
{
case 1: printf("请输入要插入的分数：\n");
scanf("%d", &x);
if (Insert_First(&Head, x) != OK)
printf("插入失败\n");
break;
case 2: printf("请输入要查询的分数\n");
loca = Location_LinkList(Head, x);
if (loca != NULL)
printf("查询成功\n");
else
printf("查询失败\n");
break;
case 3: printf("请输入要删除的分数\n");
scanf("%d", &x);
if (Delete_LinkList(&Head, x) != OK)
printf("删除失败\n");
else
printf("删除成功\n");
break;
case 4: Show_LinkList(Head);
break;
case 5: printf("表的长度是：%d", Length_LinkList(Head));
break;
case 6: break;
default: printf("错误选择！请重选");
break;
}
} while (i != 6);
SetNull_LinkList(&Head);
printf("链表已清空，程序退出...\n");
return 0;
}
‘叁’ 分别写出线性表的链式存储结构、二叉树的二叉链表存储机构的类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语言版） 线性表的链式存储
1、假设单链表为带头结点的单链表
int ListDelete(LinkList *L,int i)
{
LinkList *p; int j=0;
p=L;
while(p->next!=NULL && j<i-1)
{p=p->next; j++;
}
if (p->next==NULL || j>i-1)
{printf("不存在第i个结点\n");return 0;}
q=p->next;p->next; p->next=q->next;
free(q); return 1;
}
2、位置i和结点s的data成员在键盘输入，是要求写在函数中吗？一般应该是通过参数传递的才对啊，确认后再给你程序吧
‘伍’ 用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语言实现定义线性表的链式存储结构
#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语言二级考试循环链表是循环队列的链式存储结构
循环队列本身是一种顺序存储结构，而循环列表是一种链式存储结构。两者之间是平级关系。
线性链表是线性表的链式存储结构，包括单链表，双链表，循环链表等。
队列的顺序存储结构一般采用循环队列的形式。
循环队列的操作是按数组取摸运算的，所以是顺序存储，而循环链表本身就是收尾相连的，所以循环链表不是循环队列，两种不同的存储结构，虽然实现的功能是一样的，实现循环两种方式 顺序存储就是循环队列，链式存储就是循环链表。
(7)线性表的链式存储结构c语言扩展阅读：
1、比顺序存储结构的存储密度小(链式存储结构中每个结点都由数据域与指针域两部分组成，相比顺序存储结构增加了存储空间)。
2、逻辑上相邻的节点物理上不必相邻。
3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。
4、查找节点时链式存储要比顺序存储慢。
5、每个节点是由数据域和指针域组成。
6、由于簇是随机分配的，这也使数据删除后覆盖几率降低，恢复可能提高。
‘捌’ C语言——结构体，线性表的链式存储
结构体的数据类型是为了将不同数据类型，但相互关联的一组数据，组合成一个有机整体使用，就相当于是java中的一个对象中定义了一些不同的属性
struct 结构体类型名{
数据类型 数据项1；
数据类型 数据项2；
.....
};
例如：
struct Data{
int year;
int month;
int day;
};
间接定义法：先定义结构体类型，再定义结构体变量
struct Data data;
直接定义法：在定义结构体类型的同时，定义结构体变量
struct Data{
int year;
int month;
int day;
}data;
结构体变量.成员 ，其中通过成员运算符‘.’逐个访问其成员。
结构体变量={初始表}；
结构体数组的每一个元素，都是结构体类型数据，均包含结构体类型的所有成员。
struct std_student students[3]={
{.....};
{};
{};
};
结构体变量在内存中的起始地址称为结构体变量的指针。
struct Data data={2019,3,4};
struct Data *p=&data;
printf("%d",p->year);
一般指针变量printer指向结构体变量var：
var.成员
pointer->成员
(*pointer).成员
线性链表是线性表的链式存储结构，是一种物理存储单元上的非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现，因此，哎存储线性表中的数据元素的时候，一方面要存储数据元素的值，另一方面要存储各数据元素之间的逻辑关系，因此，将每一个节点分为两部分：数据域和指针域。
单链表的基本操作：创建，检索，插入，删除，修改。
struct 结构体名{
数据成员表；
struct 结构体名 *指针变量名；
}；
struct student{
long num;
char name[20];
int score ;
struct student *next;
};
利用malloc函数向系统申请分配链表节点的存储空间，返回存储区的首地址。
p=（struct student*）malloc（sizeof（struct student））；
需要使用free（p）来释放
线性表的基本操作：
结构体：
struct student{
int data;
struct student *next;
};
struct student stu2[5],stu1;
初始化单链表：
int Initiate(struct student *s){
if((s=(struct student*)malloc(sizeof(struct student)))==NULL){
return 0;
}
s->next=NULL;
}
单链表的插入（后插）：
main（）{
struct student *s=&stu1;
struct student *p=&stu2;
int i;
Initiate(s);
for(i=0;i<5;i++){
Initiate(p);
(p+i)->data=i;
(p+i)->next=s->next;
s->next=(p+i);
}
for(i=0;i<5;i++){
printf("%d",p[i].data);
}
}
结果：
单链表删除：
如果要删除线性表h中的第i个节点，首先要找到第i个节点并让指针p指向其前驱的第i-1个节点，然后删除第i个节点并释放被删除节点。
(p+1)->next=(p+1)->next->next;
free((p+2));
‘玖’ 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语言 建立线性表 链式 请写出代码
#include<stdio.h>
#include<stdlib.h>
typedef char elemtype;
typedef struct dnode
{elemtype data;
struct dnode *prior;
struct dnode *next;
}dlinklist;
void displist(dlinklist *L);
int listlength(dlinklist *L);
void list (void);
void initlist (dlinklist *&L);
void destorylist (dlinklist *L);
int listempty(dlinklist *L);
void listdelete (dlinklist *L,int i,elemtype &e);
void getelem (dlinklist *L,int i, elemtype &e);
int locateelem(dlinklist *L,elemtype e);
int listinsert (dlinklist *L,int i, elemtype e);
#include "head.h"
int length;
#include "head1.h"
int main (void)
{char ch;
dlinklist *L;
elemtype e;
int i;
while(1)
{list();
ch=getchar();getchar();
switch(ch)
{case '0': exit(0);
case '1': initlist(L);break;
case '2': destorylist(L);break;
case '3': printf("The length is %d\n",listlength(L));break;
case '4': if(listempty(L)) printf("表不空！\n");
else printf("表空！\n");break;
case '5': printf("请输入要取的元素的序号(1-%d)\n",length);scanf("%d",&i);getchar();
if(i>length)printf("只有%d个元素\n",length);
else if(length==0) printf("空表！\n");
else {getelem(L,i,e);printf("第%d个元素为%c\n",i,e);}break;
case '6': printf("请输入要找的元素\n"); scanf("%c",&e);getchar();i=locateelem(L,e);
if(i==0) printf("未找到！\n");
else printf("%c为第%i个元素\n",e,i);break;
case '7': printf("请输入要插入的元素及其序号(1-%d)\n",length+1);
scanf("%c%d",&e,&i);getchar();
if(listinsert(L,i,e))
printf("插入成功！\n");
else printf("插入失败！\n");break;
case '8': if(!listempty(L)) printf("空表\n");
else displist(L);break;
case '9': printf("请输入要删除的元素的序号:\n"); scanf("%d",&i);getchar();
if (i>length) printf("只有%d个元素!\n",length);
listdelete(L,i,e); printf("删除的元素为%c\n",e); break;
default: printf("输入错误！请重新输入\n");
}
}
return 0;
}
#include <stdio.h>
void list (void)
{printf("***************************************\n");
printf("1: 初始化链表 2: 释放链表\n");
printf("3: 求元素个数 4: 链表判空\n");
printf("5: 取第i 元素 6: 找元素e \n");
printf("7: 插入元素e 8: 输出链表\n");
printf("9: 删除第i 元 0: 退出程序\n");
printf("***************************************\n");
printf(" 请在上述功能中选择(0-9):");
}
#include"head.h"
extern int length;
void destorylist (dlinklist *L)
{ dlinklist *p=L->next;
if (length!=0)
{while(p!=L)
{L->next=p->next;
p->next->prior=L;
free(p);p=L->next;
}
length=0;
}
}
void displist(dlinklist *L)
{dlinklist *p=L->next;
while(p!=L)
{printf("%c ",p->data); p=p->next;}
printf("\n");
}
void getelem (dlinklist *L,int i, elemtype &e)
{int j=1;dlinklist *p=L->next;
while(p!=L&&j<i)
{p=p->next;j++;}
e=p->data;
}
extern int length;
void initlist (dlinklist *&L )
{
L=(dlinklist *)malloc(sizeof(dlinklist));
if(!L)
printf("初始化失败！\n");
else
{length=0;L->next=L->prior=L;}
}
void listdelete (dlinklist *L,int i,elemtype &e)
{dlinklist *p=L->next;
int j=1;
while(p!=L&&j<i)
{p=p->next;j++;}
if(j==i)
{p->prior->next=p->next;
p->next->prior=p->prior;
e=p->data;free(p);
length--;}
}
int listempty(dlinklist *L)
{
int i=0;
dlinklist *p=L->next;
while(p!=L)
{p=p->next;i++;}
return i;
}
int listinsert (dlinklist *L,int i, elemtype e)
{dlinklist *p=L->next,*q;int j=1;
while(p!=L&&j<i)
{p=p->next;j++;}
if(j==i)
{q=(dlinklist *)malloc(sizeof(dlinklist));
if(!q) return 0;
q->data=e; length++;
q->prior=p->prior;
p->prior->next=q;
q->next=p;
p->prior=q;
return 1;
}
else return 0;
}
int listlength(dlinklist *L)
{return length;
}
int locateelem(dlinklist *L,elemtype e)
{dlinklist *p=L->next;
int i=1;
while(p!=L&&p->data!=e)
{p=p->next;i++;}
if(p->data!=e)return 0;
else return i;
}