顺序存储结构c语言
‘壹’ 请用c语言给出顺序表（线性表的顺序结构存储结构）的类型定义
这很简单的问题啊...
#define MaxSize 100
typedef char ElemType
typedef struct
{
ElemType data[MaxSize]; //存放顺序表元素
int length; //存放顺序表的长度
}; //顺序表的类型定义
‘贰’ 用C语言给出线性表的顺序存储结构的类型定义
这很简单的问题啊...
#define
maxsize
100
typedef
char
elemtype
typedef
struct
{
elemtype
data[maxsize];
//存放顺序表元素
int
length;
//存放顺序表的长度
};
//顺序表的类型定义
‘叁’ 数据结构c语言版 使用线性表的顺序储存结构定义(静态)实现线性表的初
直接上源码吧。
/*线性表功能的实现*/
#include<stdio.h>
//定义常量 存储空间的初始化分配
#define MAXSIZE 20
#define TRUE 1
#define ERROR -1
#define FALSE 0
#define OK 1
//用typedef定义类型
typedef int Status;
typedef int ElemType;
//定义一个结构体类型
typedef struct{
ElemType data[MAXSIZE];
int length;
} sqlist;
//初始化函数
Status initList(SqList *L){
L->length = 0;
return OK;
}
//返回线性表的长度
Status getListLength(SqList L){
return L.length;
}
//线性表为空返回true,否则返回false
Status listEmpty(SqList L){
if(L.length == 0){
return TRUE;
}
return FALSE;
}
//线性表清空,长度为0
Status clearList(SqList *L){
L->length = 0;
return OK;
}
//获取指定的元素的值,返回下标为i - 1的元素,赋值给e
Status getElem(SqList L, int i, ElemType *e){
//判断元素位置是否合法[i]
if(i > L.length || i < 1){
printf("查找的位置不正确 \n");
return ERROR;
}
//判断线性表是否为空
if(listEmpty(L)){
return ERROR;
}
*e = L.data[i - 1];
return OK;
}
//在线性表中查找指定的e相等的元素,如果查找成功,返回该元素的下标,否则返回ERROR
Status locateElem(SqList L, ElemType e){
int i;
for(i = 0; i < L.length - 1; i++){
if(L.data[i] == e){
return i;
}
}
printf("没有查找到元素 %d 指定的下标\n",e);
return ERROR;
}
//自动创建 MAXSIZE 个元素,并赋值为0
Status createList(SqList *L){
int i;
for(i = 0; i < 10; i++){
L->data[i] = 0;
}
L->length = 10;
return OK;
}
//在线性表中第i个位置前插入新元素e
Status listInsert(SqList *L, int i, ElemType e){
//判断长度是否可以允许插入新的数据
if(L->length >= MAXSIZE){
printf("空间已满,不能再插入数据\n");
return FALSE;
}
//判断插入位置的合法性
if(i < 1 || i > L->length) {
printf("插入位置不正确\n");
return FALSE;
}
int j;
for(j = L->length - 1; j >= i; j--){
L->data[j] = L->data[j - 1];
}
L->data[i - 1] = e;
L->length++;
return TRUE;
}
//删除线性表中第i个元素,成功后表长减1,用e返回其值
Status deleteList(SqList *L, int i, ElemType *e){
//判断线性表是否为空
if(listEmpty(*L)){
return ERROR;
}
//判断删除的位置是否合法
if(i < 1 || i > L->length) {
printf("删除位置不合法\n");
return ERROR;
}
*e = L->data[i - 1];
for(i; i < L->length; i++){
L->data[i - 1] = L->data[i];
}
L->length--;
return TRUE;
}
//遍历线性表
Status listTraverse(SqList L){
int i;
for(i = 0; i < L.length; i++){
printf("%d ",L.data[i]);
}
printf("\n");
return OK;
}
//主程序
int main(void){
SqList L;
ElemType e;
initList(&L);
int option = 1;
int input_number;
int res;
ElemType input_value;
printf("\n1.遍历线性表 \n2.创建线性表 \n3.清空线性表 \n4.线性表插入 \n5.查找表中元素 \n6.判断元素是否在表中 \n7.删除某个元素 \n8.线性表长度\n9.线性表是否为空\n0.退出 \n请选择你的操作：\n");
while(option){
scanf("%d",&option);
switch(option){
case 0:
return OK;
break;
case 1:
listTraverse(L);
break;
case 2:
createList(&L);
listTraverse(L);
break;
case 3:
clearList(&L);
listTraverse(L);
break;
case 4:
printf("请输入插入的位置:");
scanf("%d",&input_number);
printf("\n");
printf("请输入插入的值:");
scanf("%d",&input_value);
printf("\n");
listInsert(&L, input_number, input_value);
listTraverse(L);
break;
case 5:
printf("请输入要查找的位置:");
scanf("%d",&input_number);
printf("\n");
getElem(L, input_number, &input_value);
printf("第%d个元素的值为:%d\n",input_number,input_value);
break;
case 6:
printf("请输入要查找的元素:");
scanf("%d",&input_value);
printf("\n");
res = locateElem(L, input_value);
if(res != ERROR){
printf("值为%d在表中的第%d个位置\n",input_value,input_number);
}
break;
case 7:
printf("要删除第几个元素？");
scanf("%d",&input_number);
printf("\n");
deleteList(&L, input_number, &input_value);
listTraverse(L);
break;
case 8:
res = getListLength(L);
printf("线性表的长度是:%d",res);
break;
case 9:
res = listEmpty(L);
if(res){
printf("线性表的是空的");
}else{
printf("线性表的是不是空的");
}
break;
}
}
return OK;
}
线性表的特征是:
1. 元素之间是有序的,如果元素存在多个,则第一个元素无前驱,最后一个无后继,其它元素都有且只有一个前驱和后继.
2. 元素个数是有限的. 当n=0是,称为空表
线性表实现方式有两种,分别是顺序存储结构和链式存储结构,它们之间各有优缺点 . 根据需求的不同进行选择不同的存储结构.
线性表存储结构的优缺点
优点:
1. 无须为表中元素之前的逻辑关系而增加额外的存储空间
2. 可以快速的存取表中的任一位置的元素
缺点:
1. 插入和删除操作需要移动大量元素
2. 当线性表长度变化较大时,难以确定存储空间的容量.
3. 造成存储空间的”碎片”.
‘肆’ 顺序存储结构和链式存储结构都是c语言的知识嘛
你说的顺序存储和链式存储都是数据结构的知识。其实这是一种思想，不仅可以用C语言实现，也可以用Java等其他语言实现的。
如果你要推荐教材，首推清华严蔚敏的《数据结构(C语言版)》，这是国人学习数据结构的入门课程，最适合中国人，0基础也可以学的。
如果你想学高深点的。那就看老美的《算法导论》。这个有些难度。
建议先看老严的书。
后来想想，还是给你做个链表吧：
/*链表方式模拟火车隧道*/
typedefintElemType;
typedefstructQNode{
ElemTypecarriage;/*车厢编号*/
structQNode*next;/*指针域，指向下一节车厢*/
}QNode,*QPtr;
typedefstruct{
QPtrfront;/*车头（第一届车厢）*/
QPtrrear;/*车尾（最后一节车厢）*/
}LinkQueue;
intIsEmpty(LinkQueueQ);/*判断隧道是否为空*/
voidInitQueue(LinkQueue*pQ);/*火车开始进入隧道*/
voidDeQueue(LinkQueue*pQ);/*火车出隧道*/
voidPrtHeadTail(LinkQueueQ);/*打印第一节和最后一节车厢*/
#include<stdio.h>
#include<stdlib.h>
voidmain(void)
{
/*主函数中，上面那些功能函数你可以随便调用。我这里调用顺序只是为了测试。*/
LinkQueueQ;
/*先判断隧道是否为空*/
if(IsEmpty(Q))printf("隧道为空! ");
elseprintf("隧道不空 ");
/*火车开始进入隧道*/
InitQueue(&Q);
/*在判断隧道是否为空*/
if(IsEmpty(Q))printf("隧道为空! ");
elseprintf("隧道不空 ");
/*打印车头车尾*/
PrtHeadTail(Q);
/*火车开出隧道*/
DeQueue(&Q);
}
intIsEmpty(LinkQueueQ)
{
if(Q.front==Q.rear){/*当火车头==火车尾时，可知无车厢，即为空*/
return1;/*1表示空*/
}
elsereturn0;/*0表示非空*/
}
voidInitQueue(LinkQueue*Q)
{
intCarriageNum=-1;
intSerial=-1;
inti=0;
QPtrnewCarr;
Q->front=Q->rear=(QPtr)malloc(sizeof(QNode));/*生成一个火车头*/
if(!Q->front)exit(-1);
Q->front->next=NULL;
printf("请输入有车厢数量:");
scanf("%d",&CarriageNum);
for(;i<CarriageNum;i++)/*这个循环开始生成车厢，从第一节开始。*/
{
newCarr=(QPtr)malloc(sizeof(QNode));/*生成一节车厢*/
if(!newCarr)exit(-1);
printf("请输入第%d节车厢编号:",i);
scanf("%d",&Serial);
newCarr->carriage=Serial;
newCarr->next=NULL;
Q->rear->next=newCarr;/*该车厢进入隧道*/
Q->rear=newCarr;
}
printf("列车已全部进入隧道! ");
}
voidDeQueue(LinkQueue*pQ)
{
QPtrp=NULL;
if(IsEmpty(*pQ))
{
printf("隧道为空! ");return;
}
while(!IsEmpty(*pQ))
{
p=pQ->front->next;
printf("%d",p->carriage);
pQ->front->next=p->next;
if(pQ->rear==p)
pQ->rear=pQ->front;
free(p);
}
printf("列车已全部驶出隧道! ");
}
voidPrtHeadTail(LinkQueueQ)
{
if(!IsEmpty(Q))
{
printf("第一节车厢序号为:%d ",Q.front->next->carriage);
printf("最后一节车厢序号为:%d ",Q.rear->carriage);
}
elseprintf("列车为空，没有车厢编号! ");
}
-------------------------
经测试，程序基本无差错，如有bug欢迎指正。
链式存储要比结构数组存储难一些。
我把链表的给你写出来了，至于数组存储的，你能自己写么？
‘伍’ 数据结构 c语言版 无向图的顺序存储如何理解
呵呵，是不是那本机械工业出版社的啊，很少人看这本，略难。
顺序存储用数组去存储，以行列式的形式。
你在纸上，这样画。
* 1 2 3 4
1 0
2 0
3 0
4 0
假设，有相连的为1，没相连的为0.自己不可能连自己，所以，对角线全为0.
看到没有。这里面有16个空位，准确来说是12个，剩下的，你自己依据某个特定的图去把值填上去，再将这个图，转为数组，就行了。
‘陆’ c语言的存储结构不是有顺序存储和链式存储吗
双向链表和二叉树都是数据结构，一种数据结构是不能用来描述另一种数据结构的存储方式的。
一定要分清楚存储方式，和数据结构。
‘柒’ c语言实现线性表的顺序存储结构
#include "stdio.h"
#include "stdlib.h"
int main()
{ int a[10],i,j,k,t,x;
for(i=0;i<9;i++)
a[i]=rand()%100; //给数组赋随机值范围0-100
for(i=0;i<8;i++) //数组从小到大排序
for(j=i+1;j<9;j++)
if(a[i]>a[j])
{ t=a[i];a[i]=a[j];a[j]=t;
}
//输出一维数组中的数
for(i=0;i<9;i++)
printf("%d ",a[i]);
printf("\n");
//向数组插入一个数x
scanf("%d",&x);
if(x>a[8]) a[9]=x;
else if(x<a[0])
{
for(i=9;i>0;i--)
a[i]=a[i-1];
a[0]=x;
}
else
{for(i=0;i<8;i++)
if(x>a[i]&&x<a[i+1]) k=i+1;
for(j=9;j>k;j--)
a[j]=a[j-1];
a[k]=x;
}
//输出插入后的数组
for(i=0;i<10;i++)
printf("%d ",a[i]);
printf("\n");
//删除数组中的一个元素
//输入要删除的元素的下标
scanf("%d",&k);
for(i=k;i<10;i++)
a[i]=a[i+1];
//输出删除后的数组
for(i=0;i<9;i++)
printf("%d ",a[i]);
printf("\n");
}
‘捌’ 请用C语言给出的顺序栈（栈的顺序储存结构）的类型定义
#include<stdio.h>
#include<stdlib.h>
int IsEmpty(int p)/*判断是否为空*/
{
if(p==0)
return 1;
else
return 0;
}
int Push(int p)/*入栈*/
{
p++;
return(p);
}
int Pop(int p)/*出栈*/
{
p--;
return(p);
}
void create()
{
char expression[20];
int i=0,p=0;
printf("please scan your expression which length less than 20,scan # to stop:\n");
scanf("%s",expression);
while(expression[i]!='#')
{
if(expression[i]=='(')/*如果遇到'('入栈*/
p=Push(p);
if(expression[i]==')')/*如果遇到')'且栈不为空'('出栈*/
{
if(IsEmpty(p))
{
printf("ERROR!\n");
exit(0);
}
else
p=Pop(p);
}
i++;
}
if(IsEmpty(p))
printf("OK!\n");
else
printf("ERROR!\n");
}
void main()
{
int i=0;
while(i!=-1)/*按-1退出程序运行*/
{
create();
printf("go on scan any number excepet for -1:\n");
scanf("%d",&i);
}
}
‘玖’ 用c语言描述顺序存储结构的线性表求表长的算法
#include<stdio.h>
#include<stdlib.h>
#define list_init_size 5
#define listincrement 10
#define overflow -2
typedef int status;
typedef int elemtype;
typedef struct
{
elemtype *elem;
int length;
int listsize;
} sqlist;
status initlist_sq(sqlist &L)
{
L.elem=(elemtype *)malloc(list_init_size * sizeof(elemtype));
if(!L.elem) exit(overflow);
L.length=0;
L.listsize=list_init_size;
return 1;
}
将顺序表初始化为5个元素,在结构中定义了顺序表的长度,int length:所以在主函数中可以直接调用用printf("%d",L.length)就得到了当前的长度,无论是删除,添加,L.length都会随着改变,比如我们建一个添加的函数
status listinsert_sq(sqlist &L, int i ,elemtype e)
{
int * q , *p ,* newbase;
if(i<1 || i>L.length + 1) return 0;
if(L.length >= L.listsize)
{
newbase=(elemtype *)realloc(L.elem,(L.listsize+listincrement) * sizeof(elemtype));
if(!newbase) exit (overflow);
L.elem=newbase;
L.listsize+=listincrement;
}
q=&(L.elem[i-1]);
for(p=&(L.elem[L.length-1]) ;p>=q ;--p)
*(p+1) = *p;
*q = e;
++L.length;
return 1;
}
如果加一个元素,就会把L.length自动加1,这样避免了再写函数求表长
‘拾’ C语言：为什么线性结构的顺序存储是一种随机存取存储结构谢谢
顺序存储中，一般一个元素紧紧地挨着另外的一个元素，设序号为i 的元素的存储位置为Li，每个元素长度为d，则序号为j的元素的存储位置为Li + d(j - i)，这个式子对所有元素序号（下标）都是一样的计算时间，也就是说，访问任何一个元素的时间都是相同的，因此是随机存取
当然，C语言中自然就是数组，一个接一个存放，结论一样的