順序存儲結構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語言中自然就是數組，一個接一個存放，結論一樣的