線性表的鏈式存儲結構c語言

㈠ c語言基礎知識中：線性表的順序、鏈式存儲結構分別是：隨機存取和順序存取結構對嗎

不對，數組是隨機存取，所有的線性表都是順序存取結構。你想想，我要找第5個元素，用數組直接 A[4] 就找到了，而線性表就要從「頭」元素開始一個一個地往後遍歷，直到需要的那個，隨機不了。

㈡ C語言二級考試循環鏈表是循環隊列的鏈式存儲結構

循環隊列本身是一種順序存儲結構，而循環列表是一種鏈式存儲結構。兩者之間是平級關系。

線性鏈表是線性表的鏈式存儲結構，包括單鏈表，雙鏈表，循環鏈表等。

隊列的順序存儲結構一般採用循環隊列的形式。

循環隊列的操作是按數組取摸運算的，所以是順序存儲，而循環鏈表本身就是收尾相連的，所以循環鏈表不是循環隊列，兩種不同的存儲結構，雖然實現的功能是一樣的，實現循環兩種方式 順序存儲就是循環隊列，鏈式存儲就是循環鏈表。

(2)線性表的鏈式存儲結構c語言擴展閱讀：

1、比順序存儲結構的存儲密度小(鏈式存儲結構中每個結點都由數據域與指針域兩部分組成，相比順序存儲結構增加了存儲空間)。

2、邏輯上相鄰的節點物理上不必相鄰。

3、插入、刪除靈活 (不必移動節點，只要改變節點中的指針)。

4、查找節點時鏈式存儲要比順序存儲慢。

5、每個節點是由數據域和指針域組成。

6、由於簇是隨機分配的，這也使數據刪除後覆蓋幾率降低，恢復可能提高。

㈢ 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;
}

㈣ 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就行了

㈤ 1、線性表順序存儲方式操作2、線性表鏈式存儲方法操作：。兩個都用c語言

下面是從我的博客裡面給你找的，你參考一下。更多的數據結構的內容，也可以去看我的博客。

/************************************************************
說明：
1、主函數內的代碼是為了測試方便，可以自行修改。
2、宏定義NEWS是人機交互信息提示，若不需要，可修改為0。
3、若是windows系統，請將258行中的clear修改為cls。
4、在輸入數據後，請多按一下回車，實現清屏。
環境：ubuntu12.04LTS、codeblocks10.05、2014-04-02
************************************************************/
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#include<cstring>
#defineNEWS1
#defineLIST_INIT_SIZE100
#defineLIST_ADD_SIZE10
#defineNEW_SIZE(L->list_size+LIST_ADD_SIZE)
usingnamespacestd;
typedefintElem_Type;
typedefstruct
{
Elem_Type*data;//元素
intlen;//長度
intlist_size;//空間
}Sq_List;
typedefenum
{
OK=0,//正常
ERROR=-1,//邏輯異常
OVER=-2//內存異常
}Status;
/******************************
函數名：Init_List
功能：構造、初始化線性表
******************************/
Sq_List*Init_List(void)
{
Sq_List*L=(Sq_List*)malloc(sizeof(Sq_List));
if(!L)
exit(OVER);
L->data=(Elem_Type*)malloc(LIST_INIT_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);
L->len=0;
L->list_size=LIST_INIT_SIZE;
#if(NEWS)
cout<<"構造成功，已初始化"<<endl;
#endif
returnL;
}
/******************************
函數名：Destroy_List
功能：銷毀線性表
******************************/
StatusDestroy_List(Sq_List*L)
{
free(L);
#if(NEWS)
cout<<"銷毀成功，請不要再使用"<<endl;
#endif
returnOK;
}
/******************************
函數名：Clear_List
功能：清空線性表
******************************/
StatusClear_List(Sq_List*L)
{
memset(L->data,-1,sizeof(L->data));
L->len=0;
#if(NEWS)
cout<<"已全部清空"<<endl;
#endif
returnOK;
}
/******************************
函數名：Empty_List
功能：判斷線性表是否為空
******************************/
boolEmpty_List(Sq_List*L)
{
returnL->len==0;
}
/******************************
函數名：Length_List
功能：獲取線性表長度
******************************/
intLength_List(Sq_List*L)
{
returnL->len;
}
/******************************
函數名：Get_Elem_List
功能：指定位置獲取元素
******************************/
StatusGet_Elem_List(Sq_List*L,intindex,Elem_Type*e)
{
if(!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"獲取位置不合法"<<endl
<<"下面顯示的數據是上次輸入的num的值,請注意！！！"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
returnOK;
}
/******************************
函數名：Insert_List
功能：指定位置插入元素
******************************/
StatusInsert_List(Sq_List*L,intindex,Elem_Typee)
{
if(!(1<=index&&index<=Length_List(L)+1))
#if(NEWS)
{
cout<<"插入位置不合法"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
if(Length_List(L)>=L->list_size)
#if(NEWS)
cout<<"剛才增加了存儲空間"<<endl;
#endif
L->data=(Elem_Type*)realloc(L->data,NEW_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);

L->list_size+=LIST_ADD_SIZE;

for(inti=Length_List(L);i>=index-1;i--)
L->data[i+1]=L->data[i];

L->data[index-1]=e;
L->len++;
#if(NEWS)
cout<<"插入成功"<<endl;
#endif
returnOK;
}
/******************************
函數名：Delete_List
功能：指定位置刪除元素
******************************/
StatusDelete_List(Sq_List*L,intindex,Elem_Type*e)
{
if(Empty_List(L)||!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"刪除位置不合法or目前是空表"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
for(inti=index;i<Length_List(L);i++)
L->data[i-1]=L->data[i];
#if(NEWS)
cout<<"刪除成功"<<endl;
#endif
L->len--;
returnOK;
}
/******************************
函數名：Print_List
功能：輸出所有元素
******************************/
StatusPrint_List(Sq_List*L)
{
if(Empty_List(L))
returnERROR;
inttemp;
for(inti=1;i<=Length_List(L);i++)
{
Get_Elem_List(L,i,&temp);
cout<<temp<<"";
}
cout<<endl;
returnOK;
}
/******************************
函數名：print_news
功能：方便用戶選擇
******************************/
voidprint_news(void)
{
cout<<" ********************"
<<"*****************************"<<endl
<<" * 0建立、初始化 *"<<endl
<<" * *"<<endl
<<" * 1插入元素 *"<<endl
<<" * *"<<endl
<<" * 2刪除元素 *"<<endl
<<" * *"<<endl
<<" * 3銷毀 *"<<endl
<<" * *"<<endl
<<" * 4獲取表長 *"<<endl
<<" * *"<<endl
<<" * 5清空 *"<<endl
<<" * *"<<endl
<<" * 6獲取元素 *"<<endl
<<" * *"<<endl
<<" * 7列印 *"<<endl
<<" * *"<<endl
<<" * 8退出程序 *"<<endl
<<" ********************"
<<"*****************************"<<endl;
}
intmain(void)
{
Sq_List*test=NULL;
while(true)
{
print_news();
intchoose,index,num;
cout<<"要進行什麼操作？"<<endl;
cin>>choose;
switch(choose)
{
case0:
test=Init_List();break;
case1:
cout<<"插入位置"<<endl;
cin>>index;
cout<<"插入數據"<<endl;
cin>>num;
Insert_List(test,index,num);break;
case2:
cout<<"刪除的位置"<<endl;
cin>>index;
Delete_List(test,index,&num);
cout<<"被刪除的元素是："<<num<<endl;break;
case3:
Destroy_List(test);break;
case4:
cout<<Length_List(test)<<endl;break;
case5:
Clear_List(test);break;
case6:
cout<<"獲取哪個位置的元素"<<endl;
cin>>index;
Get_Elem_List(test,index,&num);
cout<<num<<endl;break;
case7:
Print_List(test);break;
case8:
return0;
default:
break;
}
getchar();
getchar();
system("clear");
}
return0;
}

㈥ 數據結構（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 <stdlib.h>
#include <math.h>

/************************************************************************/
/* 常量定義 */
/************************************************************************/
#define ElemType int
#define Status int
#define TRUE 1
#define OK 1
#define FALSE 0
#define ERROR -1

/************************************************************************/
/* 線性表的單鏈表存儲結構*/
/************************************************************************/
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;

//////////////////////////////////////////////////////////////////////////
//
// 帶有頭結點的單鏈表的基本操作(13個)
//
//////////////////////////////////////////////////////////////////////////

/************************************************************************/
/* 操作結果：構造一個空的線性表L */
/************************************************************************/
void InitList(LinkList *L)
{
*L = (LinkList)malloc(sizeof(struct LNode)); /* 產生頭結點，並使L指向此頭結點 */
if( !*L ) /* 存儲分配失敗 */
exit(OVERFLOW);
(*L)->next = NULL; /* 指針域為空 */
}

/************************************************************************/
/* 初始條件：線性表L已存在。*/
/* 操作結果：銷毀線性表L */
/************************************************************************/
void DestroyList(LinkList *L)
{
LinkList q;
while(*L)
{
q = (*L)->next;
free(*L);
*L=q;
}
}
/************************************************************************/
/* 初始條件：線性表L已存在。*/
/* 操作結果：將L重置為空表 */
/************************************************************************/
void ClearList(LinkList L) /* 不改變L */
{
LinkList p, q;
p = L->next; /* p指向第一個結點 */
while(p) /* 沒到表尾 */
{
q = p->next;
free(p);
p = q;
}
L->next = NULL; /* 頭結點指針域為空 */
}

/************************************************************************/
/* 初始條件：線性表L已存在。*/
/* 操作結果：若L為空表，則返回TRUE，否則返回FALSE */
/************************************************************************/
Status ListEmpty(LinkList L)
{
/* 非空 */
return (L->next) ? FALSE : TRUE;
}

/************************************************************************/
/* 初始條件：線性表L已存在。操作結果：返回L中數據元素個數 */
/************************************************************************/
int ListLength(LinkList L)
{
int i = 0;
LinkList p = L->next; /* p指向第一個結點 */
while(p) /* 沒到表尾 */
{
i++;
p = p->next;
}
return i;
}

/************************************************************************/
/* L為帶頭結點的單鏈表的頭指針。*/
/* 當第i個元素存在時，其值賦給e並返回OK，否則返回ERROR */
/************************************************************************/
Status GetElem(LinkList L, int i, ElemType *e) /* 演算法2.8 */
{
int j = 1; /* j為計數器 */
LinkList p = L->next; /* p指向第一個結點 */
while(p && j < i) /* 順指針向後查找，直到p指向第i個元素或p為空 */
{
p = p->next;
j++;
}
if( !p || j > i) return ERROR; /* 第i個元素不存在 */

*e = p->data; /* 取第i個元素 */
return OK;
}

/************************************************************************/
/* 初始條件: 線性表L已存在，compare()是數據元素判定函數(滿足為1，否則為0)*/
/* 操作結果: 返回L中第1個與e滿足關系compare()的數據元素的位序。 */
/* 若這樣的數據元素不存在，則返回值為0 */
/************************************************************************/
int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
int i = 0;
LinkList p = L->next;
while(p)
{
i++;
if(compare(p->data,e)) /* 找到這樣的數據元素 */
return i;
p=p->next;
}
return 0;
}

/************************************************************************/
/* 初始條件: 線性表L已存在 */
/* 操作結果: 若cur_e是L的數據元素，且不是第一個，則用pre_e返回它的前驅 */
/* 返回OK；否則操作失敗，pre_e無定義，返回INFEASIBLE */
/************************************************************************/
Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e)
{
LinkList q, p = L->next; /* p指向第一個結點 */
while(p->next) /* p所指結點有後繼 */
{
q = p->next; /* q為p的後繼 */
if(q->data == cur_e)
{
*pre_e = p->data;
return OK;
}
p = q; /* p向後移 */
}
return ERROR;
}

/*************************************************************************/
/* 初始條件：線性表L已存在 */
/* 操作結果：若cur_e是L的數據元素，且不是最後一個，則用next_e返回它的後繼*/
/* 返回OK; 否則操作失敗，next_e無定義，返回INFEASIBLE */
/*************************************************************************/
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e)
{
LinkList p = L->next; /* p指向第一個結點 */
while(p->next) /* p所指結點有後繼 */
{
if(p->data == cur_e)
{
*next_e = p->next->data;
return OK;
}
p = p->next;
}
return ERROR;
}

/************************************************************************/
/* 在帶頭結點的單鏈線性表L中第i個位置之前插入元素e */
/************************************************************************/
Status ListInsert(LinkList L, int i, ElemType e)
{
int j = 0;
LinkList p = L, s;
while( p && j < i-1) /* 尋找第i-1個結點 */
{
p = p->next;
j++;
}
if( !p|| j > i-1) return ERROR;/* i小於1或者大於表長 */

s = (LinkList)malloc(sizeof(struct LNode)); /* 生成新結點 */
s->data = e; /* 插入L中 */
s->next = p->next;
p->next = s;
return OK;
}

/************************************************************************/
/* 在帶頭結點的單鏈線性表L中，刪除第i個元素，並由e返回其值 */
/************************************************************************/
Status ListDelete(LinkList L, int i, ElemType *e)
{
int j = 0;
LinkList p = L, q;
while(p->next && j < i-1) /* 尋找第i個結點，並令p指向其前嶇 */
{
p = p->next;
j++;
}
if( !p->next || j > i-1) /* 刪除位置不合理 */
return ERROR;
q = p->next; /* 刪除並釋放結點 */
p->next = q->next;
*e = q->data;
free(q);
return OK;
}

/************************************************************************/
/* 初始條件：線性表L已存在。操作結果：依次對L的每個數據元素調用函數vi() */
/************************************************************************/
void ListTraverse(LinkList L, void(*vi)(ElemType))
{
LinkList p = L->next;
while(p)
{
vi(p->data);
p = p->next;
}
printf("\n");
}

/************************************************************************/
/* 初始條件：線性表L已存在。列印鏈表的data域 */
/************************************************************************/
void ListPrint(LinkList L)
{
LinkList p = L->next;
while(p)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}

void printInt(int data)
{
printf("%d ", data);
}

/************************************************************************/
/* 插入排序 */
/************************************************************************/
void ListSort(LinkList L)
{
LinkList first, p, q; //為原鏈表剩下用於直接插入排序的節點頭指針
LinkList t; //臨時指針變數：插入節點

//原鏈表剩下用於直接插入排序的節點鏈表
first = L->next;

//只含有一個節點的鏈表的有序鏈表
L->next = NULL;

//遍歷剩下無序的鏈表
while (first != NULL)
{
//無序節點在有序鏈表中找插入的位置
for (t = first, q = L; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);

//退出for循環，就是找到了插入的位置
first = first->next;

p->next = t;

//完成插入動作
t->next = q;
}
}

//排序，指針交換法
void ListSort1(LinkList L)
{
LinkList head = L->next;//head指向除頭結點以外的鏈表
LinkList pre_p; //p的前驅結點
LinkList pre_q; //q的前驅結點
LinkList min; //最小的結點
LinkList p, q, temp;

for(p = head; p->next; pre_p = min, p = min->next)
{
//找出最小的結點
for(min = p, q = p; q->next; q = q->next)
{
if(q->next->data < min->data)
{
pre_q = q;
min = q->next;
}
}

//如果最小是自己 就不需要交換
if(min == p) continue;

//如果p是指向head的結點，則鏈表直接指向min
if(p == head)
L->next = min;
else
pre_p->next = min;

temp = min->next;
if(p->next == min)
{
min->next = p;
p->next = temp;
}
else
{
min->next = p->next;
pre_q->next = p;
p->next = temp;
}
}
}

//排序，數據選擇法排序
void ListSort2(LinkList L)
{
LinkList head = L->next;//head指向除頭結點以外的鏈表
LinkList min; //最小的結點
LinkList p, q; //遍歷鏈表指針
int temp;
for (p = head; p->next; p = p->next)
{
//在p指針後的鏈表選取最小的結點
for (min = p, q = p->next; q; q = q->next)
{
if (q->data < min->data)
min = q;
}

//兩者結點值不相等，數據交換
if (min->data != p->data)
{
temp = min->data;
min->data = p->data;
p->data = temp;
}
}
}

void ListSort3(LinkList L)
{
LinkList first; //指向鏈表L第一個結點，除頭結點
LinkList pre; //指向first的前驅結點
LinkList last; //指向first指向排好序的最後一個結點
LinkList rest; //指向未排好序的第一個結點，即鏈表第二個結點
LinkList curr; //指向當前結點

first = L->next; //指向第一個結點
if(first == NULL) return;

pre = L ; //pre指向first的前驅結點
last = first; //last指向排好序的最後一個結點
rest = first->next; //指向剩餘的結點
first->next = NULL; //first斷鏈

while (rest) //當餘下的結點不為空
{
//保存當前結點
curr = rest;

//取下一個結點
rest = rest->next;

//當結點小於第一個結點，則鏈接到first前面
if( curr->data < first->data )
{
pre->next = curr;
curr->next = first;
pre = curr;
}
//當前結點大於第一個結點，則鏈接到last後
else if(curr->data > first->data)
{
curr->next = last->next;
last->next = curr;
last = curr;
}
//當前結點與第一個結點相等，則鏈接到first後面
else
{
curr->next = first->next;
first->next = curr;
}
}
}

void main()
{
LinkList L;
InitList(&L);
ListInsert(L, 1, 6);
ListInsert(L, 2, 3);
ListInsert(L, 3, 67);
ListInsert(L, 4, 2);
ListInsert(L, 5, 15);
ListInsert(L, 6, 13);
ListInsert(L, 7, 10);
ListInsert(L, 8, 6);
ListInsert(L, 9, 4);

ListSort3(L);
ListTraverse(L, printInt);
}

㈨ 用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]);｝