『壹』 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;
}