線性表的順序存儲結構

⑴ 關於線性表的順序存儲結構，高手幫下~~

數位順序表 數位是指各個計數單位所佔的位置，如萬所佔的位置是萬位。每個數位上的數都有相對應的計數單位，如個位的計數單位是個，十位的計數單位是十 整數數位順序表 數級 億級 萬級 個級 數位 千億位 百億位 十億位 億位 千萬位 百萬位 十萬位 萬位 千位 百位 十位 億級 千億位 百億位 十億位 億位
萬級 千萬位 百萬位 十萬位 萬位
個級 千位 百位 十位

每個數位所代表的量 在數位順序表中，從右邊起，第一位是個位，計數單位是一，表示幾個一；第二位是十位，計數單位是十，表示幾個十；第三位是百位，計數單位是百，表示幾個百；第四位是千位，計數單位是千，表示幾個千；第五位是萬位，計數單位是萬，表示幾個萬。以此類推。 數位順序表 京 億兆 萬兆 千兆 百兆 十兆 兆 千億位 百億位 十億位 億位 千萬位 百萬位 十萬位 萬位 千位 百位 十位 個位

⑵ 線性表的順序存儲結構是隨機存取的

可以參考下面幾種解釋

1、解釋一：

順序存儲結構的地址在內存中是連續的所以可以通過計算地址實現隨機存取，與此相對 鏈式存儲結構的存儲地址不一定連續，只能通過第個結點的指針順序存取

2、解釋二：

線性表的順序存儲結構可以通過線性表的首址加偏移的方法計算出來第i個數據的位置a+i*sizeof（單個結構）而線性表的鏈式存儲結構要訪問第i個數據，就必須先訪問前面的i-1個數據

(2)線性表的順序存儲結構擴展閱讀：

線性表主要由順序表示或鏈式表示，在實際應用中，常以棧、隊列、字元串等特殊形式使用，順序表示指的是用一組地址連續的存儲單元依次存儲線性表的數據元素，稱為線性表的順序存儲結構或順序映像，順序存儲結構是隨機存取的。

鏈式表示指的是用一組任意的存儲單元存儲線性表中的數據元素，稱為線性表的鏈式存儲結構。它的存儲單元可以是連續的，也可以是不連續的。

⑶ 數據結構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. 造成存儲空間的」碎片」.

⑷ 線性表的順序存儲結構和一維數組有什麼區別哪個是靜態存儲空間

順序表是計算機內以一維數組形式表示的線性表，
線性表有鏈式存儲存與順序儲存兩種方式：
1，順序儲存結構是指用一組地址連續的存儲單元依次存儲數據元素的線性結構。
2，鏈式存儲是線性表採用指針連接的方式存儲。
線性表的長度是隨著線性表的插入刪除操作的進行而變化的，在任意時刻線性表的長度小於等於數組的長度，線性表的順序儲存是動態的，而一維數組是靜態的。

⑸ 求數據結構試驗 線性表的順序存儲結構

#include<iostream.h>
#include<stdlib.h>
#include <malloc.h>
#define OVERFLOW 0
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100//線性表存儲空間的初始增量
#define LISTINCREMENT 10 // ?
typedef struct{
int * elem;// 存儲空間基址
int length;//當前長度
int listsize;//當前分配的存儲容量
}SqList;
SqList L;
int InitList_Sq(SqList & L){
//構造一個新的線性表。
L.elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));
if(!L.elem)exit(OVERFLOW);//存儲容量失敗
L.length=0; //空表長度為0
L.listsize=LIST_INIT_SIZE;//存儲初始容量
return OK;
}//InitList_Sq
int LIstInsert_Sq(SqList & L,int i,int e){
//在順序線性表L中第i位置之前插入新的元素e
if(i<1||i>L.length+1) return ERROR;
if(L.length>=L.listsize){
int * newbase=(int *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(int));
if(!newbase)exit(OVERFLOW);
L.elem=newbase;
L.listsize+=LISTINCREMENT;
}
int * q=&(L.elem[i-1]);
for(int * p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;
*q=e;
++L.length;
return OK;
}
int ListDelete_Sq(SqList&L,int i,int &e)
{
if((i<1)||(i>L.length))return ERROR;
int *p=&(L.elem[i-1]);
e=*p;
int *q=L.elem+L.length-1;
for(++p;p<=q;++p)*(p-1)=*p;
--L.length;
return OK;
}
void main()
{
SqList L;
int i,n;
int e;
cout<<"輸入順序表的個數："<<endl;
cin>>n;
int *p=(int *)malloc(n*sizeof(int));
InitList_Sq(L);
cout<<"輸入線性表"<<n<<"個元素的值"<<endl;
for(i=0;i<n;i++)
{
cin>>p[i];
L.elem[i]=p[i];
}
cout<<endl;
L.length=i;
cout<<endl;
cout<<"輸入要插入元素的值"<<endl;
cin>>e;
cout<<endl;
cout<<"輸入要插入的位置"<<endl;
cin>>i;
LIstInsert_Sq( L, i, e);
for(i=0;i<n+1;i++)
cout<<L.elem[i];
cout<<endl;
cout<<"輸入要刪除的位置"<<endl;
cin>>i;
ListDelete_Sq(L,i,e)
;for(i=0;i<n;i++)
cout<<L.elem[i];
free(p);

⑹ 線性表的順序存儲結構是以什麼來表示數據元素之間的邏輯關系的

線性表是最基本、最簡單、也是最常用的一種數據結構。線性表（linear list）是數據結構的一種，一個線性表是n個具有相同特性的數據元素的有限序列。

線性表主要由順序表示或鏈式表示。在實際應用中，常以棧、隊列、字元串等特殊形式使用。

順序表示指的是用一組地址連續的存儲單元依次存儲線性表的數據元素，稱為線性表的順序存儲結構或順序映像（sequential mapping）。它以「物理位置相鄰」來表示線性表中數據元素間的邏輯關系，可隨機存取表中任一元素。

由此得到的存儲結構為順序存儲結構，通常順序存儲結構是藉助於計算機程序設計語言（例如c/c++）的數組來描述的。

順序存儲結構的主要優點是節省存儲空間，因為分配給數據的存儲單元全用存放結點的數據（不考慮c/c++語言中數組需指定大小的情況），結點之間的邏輯關系沒有佔用額外的存儲空間。

採用這種方法時，可實現對結點的隨機存取，即每一個結點對應一個序號，由該序號可以直接計算出來結點的存儲地址。但順序存儲方法的主要缺點是不便於修改，對結點的插入、刪除運算時，可能要移動一系列的結點。

推薦課程：C語言教程。

線性表順序存儲結構的結構代碼：

#define MAXSIZE 20

typedef int ElemType;

typedef struct

{

ElemType data[MAXSIZE];

int length; // 線性表當前長度

} SqList;

順序存儲結構封裝需要三個屬性：

存儲空間的起始位置，數組data，它的存儲位置就是線性表存儲空間的存儲位置。

線性表的最大存儲容量：數組的長度MaxSize。

線性表的當前長度：length。

注意：數組的長度與線性表的當前長度需要區分一下：數組的長度是存放線性表的存儲空間的總長度，一般初始化後不變。而線性表的當前長度是線性表中元素的個數，是會變化的。

線性表順序存儲結構的優缺點

線性表的順序存儲結構，在存、讀數據時，不管是哪個位置，時間復雜度都是O(1)。而在插入或刪除時，時間復雜度都是O(n)。

這就說明，它比較適合元素個數比較穩定，不經常插上和刪除元素，而更多的操作是存取數據的應用。

優點：

無須為表示表中元素之間的邏輯關系而增加額外的存儲空間。

可以快速地存取表中任意位置的元素。

缺點：

插上和刪除操作需要移動大量元素。

當線性表長度變化較大時，難以確定存儲空間的容量。

容易造成存儲空間的「碎片」

⑺ 線性表的順序存儲結構和線性表的鏈式存儲結構分別是

您好，

這道題的答案是B

首先解題需要了解線性表的定義，順序存儲結構和鏈式存儲結構的區別，他們分別如下：

資料擴展

定義：線性表（Linear List）是由n（n≥0）個數據元素（結點）a[0]，a[1]，a[2]…，a[n-1]組成的有限序列。

對於線性表而言，有如下幾點需要明確：

①數據元素的個數n定義為表的長度 = "list".length() （"list".length() = 0（表裡沒有一個元素）時稱為空表）

②將非空的線性表（n>=0）記作：（a[0]，a[1]，a[2]，…，a[n-1]）

③數據元素a[i]（0≤i≤n-1）只是個抽象符號，其具體含義在不同情況下可以不同，一個數據元素可以由若干個數據項組成。數據元素稱為記錄，含有大量記錄的線性表又稱為文件。這種結構具有下列特點：存在一個唯一的沒有前驅的（頭）數據元素；存在一個唯一的沒有後繼的（尾）數據元素；此外，每一個數據元素均有一個直接前驅和一個直接後繼數據元素。

綜上所述，這道題目選擇B項。

⑻ 關於線性表的順序存儲結構和線性表的鏈式存儲結構，以下選項中描述正確的是

順序存儲需要開辟一個定長的空間，讀寫速度快，缺點不可擴充容量(如果要擴充需要開辟一個新的足夠大的空間把原來的數據重寫進去) 鏈式存儲無需擔心容量問題，讀寫速度相對慢些，由於要存儲下一個數據的地址所以需要的存儲空間比順序存儲大。 我感覺java數據結構沒有c、c++來的重要。

⑼ ⑴ 線性表的順序存儲結構是一種（ ）的存儲結構，線性表的鏈接存儲結構是一種（ ）的存儲結構

線性表的順序存儲結構是一種隨機存取的存儲結構

線性表的鏈式存儲結構,是一種物理存儲單元上非連續、非順序的存儲結構

⑽ 線性表的順序存儲結構用C++實現

線性表的順序存儲結構用C++實現代碼：

#include "pch.h"

#include <stdio.h>

#include <malloc.h>

//#define DATA int

typedef int DATA;

struct SNode

{

DATA data;

SNode* pNext;

};

SNode* g_pHead = NULL;

void AddHead(DATA data)

{

SNode* p = (SNode*)malloc(sizeof(SNode));

p->data = data;

p->pNext = g_pHead;

g_pHead = p;

}

void Print()

{

SNode* p = g_pHead;

printf("List：");

while (p)//當節點的地址不為NULL

{

printf("%d ", p->data);

p = p->pNext;

}

printf(" ");

}

int main()

{

AddHead(1);

AddHead(2);

AddHead(3);

Print();

return 0;

}

程序運行結果如下：

(10)線性表的順序存儲結構擴展閱讀：

雙向鏈表框架：

#pragma once

typedef void* POSITION;

typedef int DATA;

struct SNode

{

DATA data;

SNode *pPrev, *pNext;

};

class CList

{

SNode *m_pHead, *m_pTail;

int m_nCount;

public:

CList();

~CList();

void RemoveAll();

DATA GetNext(POSITION &pos);

DATA GetPrev(POSITION &pos);

void AddHead(DATA data);

void AddTail(DATA data);

void RemoveAt(POSITION pos);

};