『壹』 線性表的鏈式存儲結構和順序存儲結構的區別
順序存儲結構就是用一組地址連續的存儲單元依次存儲該線性表中的各個元素.由於表中各個元素具有相同的屬性,所以佔用的存儲空間相同.因此,在內存中可以通過地址計算直接存取線性表中的任一元素.這種結構的特點是邏輯上相鄰的元素物理上也相鄰.用順序結構存儲的線性表稱作順序表.
線性表按鏈式存儲時,每個數據元素
(結點)的存儲包括數據區和指針區兩個部分.數據區存放結點本身的數據,指針區存放其後繼元素的地址
(沒有後繼元素時設置為空字元(Null)..只要知道該線性表的起始地址
(記錄在頭指針中),表中的各個元素就可通過其間的鏈接關系逐步找到
『貳』 鏈接存儲的存儲結構所佔存儲空間_______。
寫在前面的話：數據結構很多人都是只看不去實戰，這樣很難取得很好的效果，我會在每個知識點下面配套幾道從Leetcode和劍指offer上找到的經典題目（比如本章說完鏈表以後，會配套LeetCode.206等題目）。
程序這種東西還是多敲鍵盤比較好，紙上得來終覺淺，絕知此事要躬行。
數據結構中的線性表 是理解圖，堆棧，二叉樹的基礎，他的官方定義為：
線性表 是 零個或多個數據元素的有限序列。
比如：a1, a2, a3 ,a4, ...... , ai-1, ai, ai+1,....., an
ai-1 是ai的前驅元素，而ai+1是ai的後繼元素。我們可以得知，當i=2, ...., n-1時，他們只有唯一的一個前驅元素和後繼元素。
並且，在線性表中，a1~an所代表的元素必須是相同的數據類型的元素。（比如a1-an代表有n個不同類型的人，但他們都是人，你不能在其中添加一個帽子的存儲）。
線性表在物理結構上可以分為：順序存儲結構和鏈表存儲結構。
第一節：首先我們了解下順序存儲結構：
順序存儲結構就是在內存空間中開辟一片連續的空間，然後把數據按照順序進行存儲的一種方式。
他包含三個屬性：1、存儲空間的起始位置（也就代表我們定義了一個數組）2、最大的存儲容量（數組最大長度）3、線性表的當前長度
屬性2和3的區別是：數組的長度是基本不變的，這是我們在申請內存空間的時候就已經確定好的，而我們的線性表的長度是代表著元素個數，是不確定的長度。則兩者的關系為： 線性表的當前長度<=數組長度；
1 順序存儲結構的插入與刪除：
1.1、插入思路：
①、我們首先需要考慮異常（插入位置異常，插入後的長度異常等）
②、從最後一個元素遍歷到插入位置，分別將每一個元素向後移動一個位置；
③、插入目標元素，表長加1；
1.2、刪除思路：
①、我們仍然需要首先考慮異常（刪除位置錯誤等）
②、查找到需要刪除的位置，遍歷將其後的每一個元素向前進行移動。
2 總結
我們可以看出，在插入演算法中，順序存儲結構中元素在插入位置的過程中，多數元素都需要進行移動，來給插入的元素騰位置。並且，在刪除演算法中也是類似的道理。我們計算下他們的時間復雜度：順序存儲結構在讀取數據的時候，因為可以按照list[index]進行讀取，所以時間復雜度為O(1)，但在插入和刪除演算法的時候，平均的時間復雜度為O(n);
我們可以看出順序存儲結構的優點和缺點：
優點是：不需要為表示元素之間的邏輯關系而增加額外存儲空間，可以快速的存取表中的任一位置的元素。
缺點是：插入和刪除操作需要移動大量的元素。當線性表變化較大的時候，難以確定存儲空間的容量。
『叄』 存儲結構的概念
存儲結構的概念
數據元素之間的關系有兩種不同的表示方法:順序映象和非順序映象，並由此得到兩種不同的存儲結構:順序存儲結構和鏈式存儲結構。
數據的存儲結構是指數據的邏輯結構在計算機中的表示。
數據儲存結構
分類
順序存儲方法它是把邏輯上相鄰的結點存儲在物理位置相鄰的存儲單元里，結點間的邏輯關系由存儲單元的鄰接關系來體現，由此得到的存儲表示稱為順序存儲結構。順序存儲結構是一種最基本的存儲表示方法，通常藉助於程序設計語言中的數組來實現。
鏈接存儲方法它不要求邏輯上相鄰的結點在物理位置上亦相鄰，結點間的邏輯關系是由附加的指針欄位表示的。由此得到的存儲表示稱為鏈式存儲結構，鏈式存儲結構通常藉助於程序設計語言中的指針類型來實現。
存儲和鏈接存儲的基本原理
順序存儲和鏈接存儲是數據的兩種最基本的存儲結構。
在順序存儲中，每個存儲空間含有所存元素本身的信息，元素之間的邏輯關系是通過數組下標位置簡單計算出來的線性表的順序存儲，若一個元素存儲在對應數組中的下標位置為i，則它的前驅元素在對應數組中的下標位置為i-1，它的後繼元素在對應數組中的下標位置為i+1。在鏈式存儲結構中，存儲結點不僅含有所存元素本身的信息，而且含有元素之間邏輯關系的信息。
數據的鏈式存儲結構可用鏈接表來表示
其中data表示值域，用來存儲節點的數值部分。Pl，p2，…，Pill(1n≥1)均為指針域，每個指針域為其對應的後繼元素或前驅元素所在結點(以後簡稱為後繼結點或前驅結點)的存儲位置。通過結點的指針域(又稱為鏈域)可以訪問到對應的後繼結點或前驅結點，若一個結點中的某個指針域不需要指向其他結點，則令它的值為空(NULL)。
在數據的順序存儲中，由於每個元素的存儲位置都可以通過簡單計算得到，所以訪問元素的時間都相同;而在數據的鏈接存儲中，由於每個元素的存儲位置保存在它的前驅或後繼結點中，所以只有當訪問到其前驅結點或後繼結點後才能夠按指針訪問到，訪問任一元素的時間與該元素結點在鏈式存儲結構中的位置有關。
『肆』 線性存儲與鏈式存儲的區別
定義
順序存儲結構就是用一組地址連續的存儲單元依次存儲該線性表中的各個元素。由於表中各個元素具有相同的屬性，所以佔用的存儲空間相同。
線性表按鏈式存儲時，每個數據元素
(結點)的存儲包括數據區和指針區兩個部分。數據區存放結點本身的數據，指針區存放其後繼元素的地址只要知道該線性表的起始地址表中的各個元素就可通過其間的鏈接關系逐步找到
優缺點
順序存儲需要開辟一個定長的空間，讀寫速度快，缺點不可擴充容量(如果要擴充需要開辟一個新的足夠大的空間把原來的數據重寫進去)
鏈式存儲無需擔心容量問題，讀寫速度相對慢些，由於要存儲下一個數據的地址所以需要的存儲空間比順序存儲大。
『伍』 線性順序存儲結構和鏈式存儲結構有什麼區別
區別：
1、順序存儲需要開辟一個定長的空間，讀寫速度快，缺點不可擴充容量(如果要擴充需要開辟一個新的足夠大的空間把原來的數據重寫進去)。
2、鏈式存儲無需擔心容量問題，讀寫速度相對慢些，由於要存儲下一個數據的地址所以需要的存儲空間比順序存儲大。
『陸』 比較順序存儲和鏈接存儲兩種存儲結構的優缺點。（參考教材4.1）
/*****************************************************
順序表演算法
嚴格按照《數據結構C語言版》實現
敬請指正
vincent
2006-12-28
******************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int Status;
typedef int ElemType;
/*C中的函數指針類型*/
typedef Status (*cmp)(ElemType x,ElemType i);
typedef void (*vis)();
struct sqlist{
ElemType *elem;
int length;
int listsize;
};
/*創建新的順序表*/
Status InitList(SqList &L);
/*銷毀順序表*/
Status DestroyList(SqList &L);
/*如果順序表為空TRUE 否則FALSE*/
Status ListEmpty(SqList &L);
/*返回順序表長度*/
int ListLength(SqList &L);
/*返回指定位置的元素*/
ElemType GetElem(SqList &L,int i,ElemType *e);
/*定位指定元素，如果有返回第一個匹配的元素的位置*/
int LocateElem(SqList &L,ElemType e,cmp f);
/*int LocateElem_sq(SqList &L,ElemType e);*/
/*返回當前元素的前一個元素*/
ElemType PriorElem(SqList &L,int pos,ElemType *pre_e);
/*返回當前元素的後一個元素*/
ElemType NextElem(SqList &L,int pos,ElemType *next_e);
/*清空表*/
Status ClearList(SqList &L);
/*在指定位置插入元素*/
Status ListInsert(SqList &L,int i,ElemType e);
/*刪除指定位置的元素*/
Status ListDelete(SqList &L, int i, ElemType e);
/*遍歷順序表*/
Status ListTraverse(SqList &L, vis v);
/*在順序表中比較元素e*/
Status compare(ElemType x,ElemType i);
/*visit 函數在遍歷表時返回當前元素*/
void visit(SqList &L);
main(){
int i,t ;
ElemType a;
int b;
cmp f;
SqList L;
ElemType *e;
if(!InitList(L)){
printf("E001\n");
exit(ERROR);
}
printf("請輸入數字，默認為5個\n");
for(i =1;i <= 5; i++){
int z[5] ;
scanf("%d",&z[i-1]);
if (!ListInsert(L,i,z[i-1])){
printf("E002\n");
exit(ERROR);
}
}
printf("結果是:\n");
for(i = 1 ; i <= L.length;i++){
printf("%d\n",GetElem(L,i,e));
}
/*返回表長*/
printf("%d\n",ListLength(L));
a=3;
printf("%d\n",LocateElem(L,a, f));
DestroyList(L);
}
/*構造一個空表*/
Status InitList(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 OK;
}
/*銷毀一個表*/
Status DestroyList(SqList &L) {
if(!L.elem)exit(ERROR);
free(L.elem);
L.elem = NULL;
//L = NULL;
return OK;
}
/*如果順序表為空TRUE 否則FALSE*/
Status ListEmpty(SqList &L){
if(L.elem == NULL){
return TRUE;
}
else {
return FALSE;
}
}
/*返回順序表長度*/
int ListLength(SqList &L){
if(!L.elem)exit(ERROR);
return L.length;
}
/*返回指定位置的元素*/
ElemType GetElem(SqList &L,int i,ElemType *e){
if(!L.elem || i > L.length || i < 1 )exit(ERROR);
/*e = L.elem + sizeof(ElemType)*(i-1);*/
e = L.elem + i - 1;
return *e;
}
/*定位指定元素，如果有返回第一個匹配的元素的位置*/
int LocateElem(SqList &L,ElemType e,cmp f){
//f = compare(ElemType x,int i);
int z,s;
ElemType *y;
if(!L.elem) exit(ERROR);
for(z=0;z<= L.length;z++){
/*y = L.elem + sizeof(ElemType)*z;*/
y = L.elem + z;
s = f(*y,e);
if (s == TRUE) return z;
}
return 0;
}
/*在順序表中比較元素e*/
Status compare(ElemType x,ElemType i){
if (x == i) return TRUE;
return FALSE;
}
/*返回當前元素的前一個元素*/
ElemType PriorElem(SqList &L,int pos,ElemType *pre_e){
if(pos > L.length || pos < 2) exit(ERROR);
pre_e = L.elem + pos -1;
return *pre_e;
}
/*返回當前元素的後一個元素*/
ElemType NextElem(SqList &L,int pos,ElemType *next_e){
if(pos > L.length -1 || pos < 1)exit(ERROR);
next_e = L.elem + pos +1;
return *next_e;
}
/*清空表將表中元素去掉，設置長度為0*/
Status ClearList(SqList &L){
int i;
if(!L.elem)exit(ERROR);
free(L.elem);
L.length = 0;
return OK;
}
/*在指定位置插入元素*/
Status ListInsert(SqList &L,int i,ElemType e){
ElemType *p,*q,*newbase;
if(i <1 || i > L.length +1){
printf("E004\n");
return(ERROR);
}
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 OK;
}
/*刪除指定位置的元素*/
Status ListDelete(SqList &L, int i, ElemType e){
ElemType *p,*q;
if(i <1 || i > L.length +1)return(ERROR);
p = &(L.elem[i - 1]);
e = *p;
q = L.elem + L.length -1;
for(++p;p <= q;++p) *(p-1) = *p;
--L.length;
return OK;
}
『柒』 C語言編程 幫幫忙哦~~比較順序存儲和鏈接存儲兩種存儲結構的優缺點
(1) 分別用順序存儲和鏈接存儲實現線性表的基本操作
順序存儲:
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0
#define List_Init_Size 10
#define ListIncrement 2
typedef char ET;
typedef ET * Ep;
typedef int Status;
typedef struct {
ET *elem;
int Length;
int ListSize;
} SqList;
SqList La,Lb,Lc;
/*This program provide some functions for linear table.
Header file writen user are sqlist.h */
#include"stdio.h"
#include"alloc.h"
#include"sqlist.h"
SqList La,Lb,Lc;
/*Output the linear table emements. */
void printsq(SqList *L) {
int i;
printf("Size=%d Length=%d ",L->ListSize,L->Length);
for (i=0;i<L->Length;i++)
printf("%3c",L->elem[i]);
printf("\n");
}
Status InitList( SqList *L){
L->elem=(Ep)malloc(List_Init_Size*sizeof(ET));
if(L->elem==NULL)
exit(OVERFLOW);
L->Length=0;
L->ListSize=List_Init_Size;
return OK;
}
Status Init(SqList *L) {
int done=TRUE;
ET e;
InitList(L);
while (done) {
scanf("%c",&e);
if (e != '\n')
ListInsert(L,L->Length+1,e);
else done = FALSE;
}
}
/*Insert the ith data into a linear table */
Status ListInsert(SqList *L,int i,ET e){
ET *p,*q;
if (i<1 || i>L->Length+1) return ERROR;
if(L->Length >= L->ListSize){
p=(ET*)realloc(L->elem,(L->ListSize+ListIncrement)*sizeof(ET));
if (p==NULL)exit(OVERFLOW);
L->elem=p;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 OK;
}
Status Insert(SqList *L) {
int i,flag;
ET data;
printf("Please input the position and data: ");
scanf("%d",&i);
printf("Please input the data : ");
data = getche();
flag = ListInsert(L,i,data);
return flag;
}
/*Delete the ith data from a linear table*/
Status ListDelete(SqList *L,int i,ET *e) {
ET *p,*q;
}
Status Delete(SqList *L) {
int i,flag;
ET e;
}
/* Get element from a linear table. */
Status GetElem(SqList *L , int i , ET *e){
}
int LocateElem(SqList *L,ET e) {
int i,flag=FALSE;
}
/*Merge two linear table into one. If they have the same elements,
keep one of them and delete another. */
void Union( SqList *La ,SqList *Lb){
int i;
ET e;
}
}
/*Merge two sequence into one,don't change any elements in
these two linear tables. Join two sequence to one. */
void MergeList(SqList *L1,SqList *L2,SqList *L3) {
int i=0,k=0,j=0;
ET ai,bj;
while((i<L1->Length)&&(j<L2->Length)) {
ai=*(La.elem+i);
bj=*(Lb.elem+j);
if(ai<=bj) {
ListInsert(L3,++k,ai);
++i;
}
else {
ListInsert(L3,++k,bj);
++j;
}
}
while (i<L1->Length){
ai=*(L1->elem+i);
ListInsert(L3,++k,ai);
i++;
}
while(j<L2->Length){
bj=*(L2->elem+j);
ListInsert(L3,++k,bj);
j++;
}
}
/*List the Menu*/
void MenuList() {
printf("\n\n\n**************************\n");
printf(" 1 ------- Insert LA\n");
printf(" 2 ------- Insert LB\n");
printf(" 3 ------- Union LA and LB\n");
printf(" 4 ------- Delete LA\n");
printf(" 5 ------- Delete LB\n");
printf(" 6 ------- Merge LA and LB to LC\n");
printf(" 7 ------- print Linear\n");
printf(" 8 ------- Exit\n");
printf("**************************\n");
}
/*Select the menu */
void MenuSelect( ){
int select,done=1;
while (done) {
MenuList( );
printf("input the operating code : ");
scanf("%d",&select);
switch(select){
case 1: Insert(&La);break;
case 2: Insert(&Lb);break;
case 3: Union(&La,&Lb);break;
case 4: Delete(&La);break;
case 5: Delete(&Lb);break;
case 6: InitList(&Lc);
MergeList(&La,&Lb,&Lc);
printf("LC: ");printsq(&Lc);
break;
case 7: printf("LA: ");printsq(&La);
printf("LB: ");printsq(&Lb);break;
case 8: done=0;break;
default: printf(" ERROR\n");
}
}
}
main( ){
printf("Please input the init LA's element : ");
Init(&La) ;
printf("Please input the init LB's element : ");
Init(&Lb) ;
MenuSelect();
}
鏈接存儲:
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define TRUE 1
#define FALSE 0
#define List_Init_Size 10
#define ListIncrement 2
typedef char ET;
typedef ET * Ep;
typedef int Status;
typedef struct LNode{
ET data;
struct LNode *next;
}LNode, *LinkList;
/*LinkList La,Lb,Lc;*/
#include "stdio.h"
#include "alloc.h"
#include "llist.h"
/*Display the linklist's elements. */
void printlk(LinkList L) {
}
/*Creat linklist from head node. */
void CreatList( LinkList *L,int n){
int i;
LinkList p,q;
ET str[20],c;
p=(LinkList)malloc(sizeof(LNode));
p->next=NULL;
*L = q = p;
printf("Please input the data : ");
for (i=n;i>0;i--) {
p=(LinkList)malloc(sizeof(LNode));
c = getche(); /*scanf("%c",&c);*/
printf("\n\n");
p->data = c;
p->next = q->next;
q->next = p;
}
}
/*Init the linklist. */
void Init(LinkList *L) {
int n;
printf("Please input the number of the node : ");
scanf("%d",&n);
CreatList(L,n);
}
/* Get the value of element I; */
int GetElem(LinkList L,int i,ET *e) {
/* Add your own codes. */
}
/*Insert a element after I */
int ListInsert(LinkList *L,int i,ET e) {
/* Add your own codes. */
}
/*Delete the element I */
int ListDelete(LinkList *L,int i,ET *e)
{
/* Add your own codes. */
}
int Insert(LinkList *L) {
int i,flag;
ET data;
printf("Please input the position : ");
scanf("%d",&i);
printf("Please input the data : ");
data = getche(); /*scanf("%c",&data);*/
flag = ListInsert(L,i,data);
return flag;
}
Status Delete(LinkList *L) {
int i,flag;
ET e;
printf("Please input the number : ");
scanf("%d",&i);
flag = ListDelete(L,i,&e);
printf("Deleted element is %c\n",e);
return flag;
}
/*Find the element's position. */
int LocateElem(LinkList L,ET e) {
int i=0;
LinkList p;
p = L->next;
while (p) {
i++;
if (p->data == e) return i;
}
return 0;
}
/*Add the Lb after the La. */
void Union( LinkList *La ,LinkList *Lb){
LinkList pa,pb;
/* Add your own codes. */
}
/*Merge two sequence into one,don't change any elements in
these two link lists. Join two sequence to one. */
void MergeList(LinkList *L1,LinkList *L2,LinkList *L3) {
LinkList pa,pb,pc;
/* Add your own codes. */
}
/*List the Menu*/
void MenuList() {
printf("\n\n\n==========================\n");
printf(" 1 ******* Insert LA\n");
printf(" 2 ******* Insert LB\n");
printf(" 3 ******* Delete LA\n");
printf(" 4 ******* Delete LB\n");
printf(" 5 ******* Union LA and LB\n");
printf(" 6 ******* Merge LA and LB to LC\n");
printf(" 7 ******* print LinkList\n");
printf(" 8 ******* Exit\n");
printf("==========================\n");
}
/*Select the menu */
void MenuSelect(LinkList *La,LinkList *Lb){
int select,done=1;
LinkList Lc;
while (done) {
MenuList( );
printf("input the operating code : ");
scanf("%d",&select);
switch(select){
case 1: Insert(La);break;
case 2: Insert(Lb);break;
case 3: Delete(La);break;
case 4: Delete(Lb);break;
case 5: Union(La,Lb);break;
case 6: MergeList(La,Lb,&Lc);
printf("LC: ");printlk(Lc);
break;
case 7: printf("LA: ");printlk(*La);
printf("LB: ");printlk(*Lb);
break;
case 8: done=0;break;
default: printf(" ERROR\n");
}
}
}
main( ){
LinkList La,Lb;
printf("LA ");
Init(&La) ;
printlk(La);
printf("LB ");
Init(&Lb) ;
printlk(Lb);
MenuSelect(&La,&Lb);
}
(2) 比較兩者的優缺點，並說明兩者的適用場合
順序存儲:
要求存儲的空間物理上連續，但是可以直接完成查找。
鏈接存儲：
不用物理相鄰，邏輯上採用指針連續，儲存要求不高，但是查找要花更多的時間，修改很方便。
所以，在建立的線性表不需要進行大量的修改，需要查找的時候，就用順序存儲；不經常查找，但是經常進行修改的時候，就用鏈式存儲。
自己的理解，應該正確～
『捌』 單鏈表是一種鏈接存儲結構,但它屬於順序存儲結構,為什麼
你把他理解成很多人在排隊買票，並且每個人都是被一根繩子連在一起的。
『玖』 棧的順序存儲和鏈表存儲的差異
順序存儲： 線性表的順序表：指的是用一組地址連續的存儲單元，依次存儲線性表的數據元素。
線性表的順序存儲結構具備如下兩個基本特徵： 1、線性表中的所有元素所佔的存儲空間是連續的（即要求內存中可用存儲單元的地址必須是連續的）。 2、線性表中各數據元素在存儲空間中是按邏輯順序依次存放的。 即：線性表邏輯上相鄰、物理也相鄰（邏輯與物理統一：相鄰數據元素的存放地址也相鄰），則已知第一個元素首地址和每個元素所佔位元組數，則可求出任一個元素首地址。 優點： 1、
無須為表示結點間的邏輯關系而增加額外的存儲空間。
2、
可以方便的隨機存取表中的任一結點。
3、
存儲密度大（＝1），存儲空間利用率高。 缺點： 1、
插入和刪除運算不方便，需移動大量元素。 2、
由於要求佔用連續的存儲空間，存儲分配只能按最大存儲空間預先進行，致使存儲空間不能得到充分利用。
3、
表的容量難以擴充。 鏈表存儲： 線性表的鏈式存儲：指用一組任意的存儲單元存儲線性表中的數據元素。
線性表的鏈式存儲結構具備的基本特徵： 鏈式存儲時，相鄰數據元素可隨意存放，但所佔存儲空間分兩部分，一部分存放結點值，另一部分存放表示結點間關系的指針。 優點： 1、
插入、刪除操作很方便，可通過修改結點的指針實現，無須移動元素。
2、
方便擴充存儲空間。
缺點： 1、
不能隨機存取元素。
2、
存儲密度小（<1），存儲空間利用率低。 總結： 1、
順序表適宜於做查找這樣的靜態操作；
鏈表宜於做插入、刪除這樣的動態操作。 2、若線性表的長度變化不大，且其主要操作是查找，則採用順序表； 若線性表的長度變化較大，且其主要操作是插入、刪除操作，則採用鏈表。
『拾』 文件順序存取與隨機存取的主要區別是什麼它們對有結
文件的存取方法分為順序存取和直接存取。一般來說，對順序存取的文件，文件系統可把它組織成順序文件和鏈接文件；對於隨機存取的文件，文件系統可把它組織成索引文件。但索引文件也可以進行順序存取。
1、隨機存取（有時亦稱直接訪問）代表同一時間訪問一組序列中的一個隨意組件。反之則稱循序訪問，即是需要更多時間去訪問一個遠程組件。隨機存取存儲器的基本結構可分為三個部分：存儲矩陣，地址解碼器，讀寫電路。
2、直接存取，訪問時讀寫不見先直接指向一個小區域，再在該區域內
順序查找，訪問時間與數據位置有關（
磁碟）