線性表的順序存儲結構源碼

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

B. 1、 建立線性表的（動態分配）順序存儲結構。

屁話！我倒知道你編譯失敗！你的主函數main呢？？？下面的是我寫的。

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int ElemType;
typedef int Status;
typedef struct{
ElemType *elem;
int length;
int listsize;
}Sqlist;
Status InitList_Sq(Sqlist *L) {//千萬注意這里的參數是×L ，而不是&L，為什麼？
L->elem = (ElemType *) malloc (LIST_INIT_SIZE * sizeof(ElemType) );//這里為什麼是L->elem,而不是L.elem？
if(!L->elem) exit( OVERFLOW );
L->length=0;
L->listsize = LIST_INIT_SIZE;
return OK;//這句話純屬廢話
}

int main(void) {

Sqlist A;

InitList_Sq(&A);

}//

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

查找：
順序表的順序查找演算法：
int Seqsearch1(int r[],int n,int k)
{
r[0]=k;
i=n;
while(r[i]!=k)
i--;
return i;
}
單鏈表的順序查找演算法：
int Seqsearch2(Node<int> *first,int k)
{
p=first->next;j=1;
while(p!=NULL&&p->data!=k)
{
p=p->next;
j++;
}
if(p->data==k)return j;
else return 0;
}
折半查找：
非遞歸
int Binsearch1(int r[],int n,int k)
{
high=n;low=1;
while(low<=high)
{
mid=(high+low)/2;
if(k<mid) high=mid-1;
else if(k>mid) low=mid+1;
else return mid;
}
return 0;
}
遞歸
int Binsearch2(int r[],int low,int high,int k)
{
if(low>high) return 0;
else
{
mid=(low+high)/2;
if(K<mid) return Binsearch2(r,low,mid-1,k);
else if(K>mid) return Binsearch2(r,mid+1,high,k);
else return mid;
}
}
二叉樹排序：
class BiSortTree
{
public:
BiSortTree(int a[],int n);
~BiSortTree();
void InsertBST(BiNode<int> *root,BiNode<int> *s);
void DeleteBST(BiNode<int> *p,BiNode<int> *f);
BiNode<int>* SearchBST(BiNode<int> *root,int k);
private:
BiNode<int> *root;
};
void BiSortTree::InsertBST(BiNode<int> *root,BiNode<int> *s);
{
if(root==NULL) root=s;
else if(s->data<root->data) InsertBST(root->lchild,s);
else InsertBST(root->rchild,s);
}
BiSortTree::BiSortTree(int r[],int n)
{
for(i=0;i<n;i++)
{
s=new BiNode<int>;s->data=r[i];
s->lchild=s->rchild=NULL;
InsertBST(root,s);
}
}
void BiSortTree::DeleteBST(BiNode<int> *p,BiNode<int> *f)
{
if(!p->lchild&&!p->rchild)
{
f->lchild=NULL;
delete p;
}
else if(!p->lchild)
{
f->lchild=p->rchild;
delete p;
}
else if(!p->rchild)
{
f->lchild=p->lchild;
delete p;
}
else
{
par=p;s=p->rchild;
while(s->lchild!=NULL)
{
par=s;
s=s->lchild;
}
p->data=s->data;
if(par==p) par->rchild=s->rchild;
else par->lchild=s->rchild;
delete s;
}
}
BiNode<int> *BiSortTree::SearchBST(BiNode<int> *root,int k)
{
if(root==NULL) return NULL;
else if(root->data==k) return root;
else if(root->data<k) return SearchBST(root->lchild,k);
else return SearchBST(root->rchild,k);
}
閉散列表的查找演算法：
int HashSearch1(int ht[],int m,int k)
{
j=H[k];
if(ht[j]==k) return j;
i=(j+1)%m;
while(ht[i]!=Empty&&i!=j)
{
if(ht[i]==k) return i;
i=(i+1)%m;
}
if(i==j) throw"溢出";
else ht[i]=k;
}
開散列表的查找演算法：
Node<int> *HashSearch2(Node<int> *ht[],int m,int k)
{
j=H[k];
p=ht[j];
while(p&&p->data!=k)
p=p->next;
if(p->data==k) return p;
else
{
q=new Node<int>;q->data=k;
q->next=ht[j];
ht[j]=q;
}
}
排序：
插入
直接插入排序演算法：
void InsertSort(int r[],int n)
{
for(i=2;i<=n;i++)
{
r[0]=r[i];
for(j=i-1;r[0]<r[j];j--)
r[j+1]=r[j];
r[j+1]=r[0];
}
}
希爾排序演算法：
void ShellSort(int r[],int n)
{
for(d=n/2;d>=1;d=d/2)
{
for(i=d+1;i<=n;i++)
{
r[0]=r[i];
for(j=i-d;j>0&&r[0]<r[j];j=j-d)
r[j+d]=r[j];
r[j+d]=r[0];
}
}
}
交換
起泡排序：
void BubbleSort(int r[],int n)
{
exchange=n;
while(exchange)
{
bound=exchange;exchange=0;
for(j=1;j<bound;j++)
if(r[j]>r[j+1])
{
r[j]<-->r[j+1];
exchange=j;
}
}
}
快速排序：
int Partition(int r[],int first,int end);
{
i=first;j=end;
while(i<j)
{
while(i<j&&r[i]<=r[j]) j--;
if(i<j)
{
r[i]<-->r[j];
i++;
}
while(i<j&&r[i]<=r[j]) i++;
if(i<j)
{
r[i]<-->r[j];
j--;
}
}
return i;
}
void QuickSort(int r[],int first,int end)
{
if(first<end)
{
pivot=partition(r,first,end)
QuickSort(r,first,pivot-1);
QuickSort(r,pivot+1,end);
}
}
選擇
簡單選擇排序：
void SelectSort(int r[],int n)
{
for(i=1;i<n;i++)
{
index=i;
for(j=i+1;j<n;j++)
if(r[j]<r[index]) index=j;
if(index!=i) r[i]<-->r[index];
}
}
堆排序：
void Sift(int r[],int k,int m)
{
i=k;j=2*i;
while(j<=m)
{
if(j<m&&r[j]<r[j+1])j++;
if(r[i]>r[j]) break;
else
{
r[i]<-->r[j];
i=j;j=2*i;
}
}
}
void HeapSort(int r[],int n)
{
for(i=n/2;i>=1;i--)
sift(r,i,n);
for(i=1;i<n;i++)
{
r[1]<-->r[n-i+1];
sift(r,1,n-i);
}
}
歸並
二路歸並排序：
void Merge(int r[],int r1[],int s,int m,int t)
{
i=s;j=m+1;k=s;
while(i<=m&&j<=t)
{
if(r[i]<=r[j]) r1[k++]=r[i++];
else r1[k++]=r[j++];
}
if(i<=m) while(i<=m)
r1[k++]=r[i++];
else while(j<=t)
r1[k++]=r[j++];
}
void Merge(int r[],int r1[],int n,int h)
{
i=1;
while(i<=n-2h+1)
{
Merge(r,r1,i,i+h-1,i+2h-1);
i=i+2*h;
}
if(i<n-h+1) Merge(r,r1,i,i+h-1,n)
else for(k=i;k<=n;k++)
r1[k]=r[k];
}
void MergeSort1(int r[],int r1[],int n)
{
h=1;
while(h<n)
{
MergePass(r,r1,n,h);
h=2*h;
MergePass(r1,r,n,h);
h=2*h;
}
}
void MergeSort2(int r[],int r1[],int s,int t)
{
if(s==t) r1[s]=r[t];
else
{
m=(s+t)/2;
MergeSort2(r,r1,s,m);
MergeSrot2(r,r1,m+1,t);
Merge(r1,r,s,m,t);
}
}

D. 求 線性表的順序存儲結構 一數的插入 謝謝

#include <stdio.h>
#include <malloc.h>
#include <conio.h>
#include <ctype.h>
#include <stdlib.h>
#define OK 1
#define ERROR 0
#define list_init_size 100 //線性表存儲空間的初始分配量
#define list_increament 10 //線性表存儲空間的分配增量
typedef int elemtype;
struct node
{
elemtype * elem;
int length;
int listsize;
};
typedef struct node sqlist;

//初始化一個空的順序表L，若初始化成功返回1，否則返回0。
int initlist_sq(sqlist *l,int n)
{
int i;
l->elem=(elemtype *)malloc(list_init_size*sizeof(elemtype));
if(!(l->elem))
{
printf("內存分配失敗.\n");
return ERROR;
}
printf("請輸入線性表中的元素:\n");
for(i=0;i<n;i++)
scanf("%d",&(l->elem[i]));
printf("\n");
l->length=n;
l->listsize=list_init_size;
return OK;
}

//列印線性表
void print_sq(sqlist *l)
{
int i,j=1;
for(i=0;i<l->length;i++)
{
printf("%4d",l->elem[i]);
j++;
if(j%10==0)
printf("\n");
}
printf("\n該線性表的長度是%d.\n",l->length);
printf("\n該線性表的最大容量是%d.\n",l->listsize);
}

//從線性表L中取第i個元素，並由e帶出。若取元素成功則返回1，取元素不成功返回0。
int getelem_sq(sqlist *l,int i,elemtype *e)
{
if(i>0&&i<=l->length)
{
*e=l->elem[i-1];
return OK;
}
else
{
printf("輸入的位置有問題\n");
return ERROR;
}

}

//判斷線性表L是否為空表，若是空表返回1，若不是空表返回0。
int listempty_sq(sqlist *l)
{
if(l->length>0)
{
printf("該線性表不為空.\n");
return ERROR;
}
else
{
printf("該線性表為空.\n");
return OK;
}
}

//清空一個線性表L，若清空成功返回1。
int clearlist_sq(sqlist *l)
{
l->length=0;
printf("該線性表已清空.\n");
return OK;
}

//在線性表L中找cure的前驅結點並由pre_e帶出。
void priorelem_sq(sqlist *l,int cur_e,elemtype *pre_e)
{
int i;
int flag=0;
if(l->elem[0]==cur_e)
{
printf("第一個元素沒有前驅結點.\n");
flag=1;
}
else
{
for(i=1;i<l->length;i++)
{
if(l->elem[i]==cur_e)
{
*pre_e=l->elem[i-1];
printf("該線性表中第%d個元素%d的前驅結點是%d\n",i+1,cur_e,*pre_e);
flag++;
}
else
continue;

}
}
if(flag==0)
printf("在該線性表中找不見元素%d\n",cur_e);

}

//在線性表L中找cure的後繼結點，若有則由next_e帶出。
void nextelem_sq(sqlist *l,int cur_e,elemtype *next_e)
{
int i;
int flag=0;
if(l->elem[l->length-1]==cur_e)
{
printf("最後一個元素沒有後繼結點.\n");
flag=1;
}
else
{
for(i=1;i<l->length;i++)
{
if(l->elem[i]==cur_e)
{
*next_e=l->elem[i+1];
printf("該線性表中第%d個元素%d的後繼結點是%d\n",i+1,cur_e,*next_e);
flag++;
}
else
continue;

}
}
if(flag==0)
printf("在該線性表中找不見元素%d\n",cur_e);

}

//返回線性表的長度
int listlength_sq(sqlist *l)
{
return(l->length);
}

//在線性表L的第i個位置插入一個數據元素e。插入不成功返回0。
int listinsert_sq(sqlist *l,int i,elemtype e)
{
int j;
elemtype * newbase;
if(i<1||i>l->length+1)
{
printf("插入的位置錯誤\n");
return ERROR;
}
if(l->length>=l->listsize)
{
newbase=(elemtype *)realloc(l->elem,(l->listsize+list_increament)*sizeof(elemtype));
if(!newbase)
{
printf("內存在擴充時失敗");
return ERROR;
}
l->elem=newbase;
l->listsize=l->listsize+list_increament;
}
for(j=l->length-1;j>=i-1;j--)
l->elem[j+1]=l->elem[j];
l->elem[i-1]=e;
l->length++;
return OK;

}

//刪除線性表L中的第i個數據元素,並由e帶出刪除的元素，若刪除不成功返回0。
int listdelete_sq(sqlist *l,int i,elemtype *e)
{
int j;
if(i<1||i>l->length)
{
printf("輸入的位置有問題\n");
return ERROR;
}
*e=l->elem[i-1];
for(j=i;j<=l->length-1;j++)
l->elem[j-1]=l->elem[j];
l->length--;
return OK;
}

//將現有的線性表置逆。
void convert_sq(sqlist *l)
{
int i,j,t;
for(i=0,j=l->length-1;i<j;i++,j--)
{
t=l->elem[i];
l->elem[i]=l->elem[j];
l->elem[j]=t;

}
}

//將非遞減的有序表La和Lb歸並為一個新的非遞減的有序表Lc。
int mergelist_sq(sqlist *la,sqlist *lb,sqlist *lc)
{
elemtype *pa,*pb,*pc,*pa_last,*pb_last;
pa=la->elem;
pb=lb->elem;
pa_last=la->elem+la->length-1;
pb_last=lb->elem+lb->length-1;
lc->listsize=lc->length=la->length+lb->length;
lc->elem=(elemtype*)malloc((la->length+lb->length)*sizeof(elemtype));
pc=lc->elem;
while(pa<=pa_last&&pb<=pb_last)
{
if(*pa<*pb)
*pc++=*pa++;
else
*pc++=*pb++;
}
while(pa<=pa_last)
*pc++=*pa++;
while(pb<=pb_last)
*pc++=*pb++;
return OK;
}

//La和Lb中的元素分別表示兩個集合A和B，求一個新的集合A=（A-B）∪(B-A)。
int unionl(sqlist *la,sqlist *lb)
{
int i,j;
elemtype *newbase;
if(la->length+lb->length>la->listsize)
newbase=(elemtype*)realloc(la->elem,(la->listsize+list_increament)*sizeof(elemtype));
if(!newbase)
{
printf("\na表的長度不夠，且內存分配失敗");
return ERROR;
}
for(i=1;i<=lb->length;i++)
{
for(j=1;j<=la->length;j++)
if(lb->elem[i-1]==la->elem[j-1])
break;
else
continue;
if(j>la->length)
{
la->elem[j-1]=lb->elem[i-1];
la->length++;
}
}
return OK;
}

void deld_sq(sqlist *l)
{
int i,j,k;
elemtype s;
for(i=0;i<=l->length-2;i++)
for(j=i+1;j<=l->length-1;j++)
if(l->elem[i]==l->elem[j])
{
for(k=j;k<=l->length-2;k++)
l->elem[k]=l->elem[k+1];
l->length--;
j--;
}
for(i=0;i<=l->length-2;i++)
for(j=i+1;j<=l->length-1;j++)
if(l->elem[i]>l->elem[j])
{
s=l->elem[i];
l->elem[i]=l->elem[j];
l->elem[j]=s;
}
}

//在線性表L中查找與k相匹配的元素，返回在表中的位置。
void sqsearch(sqlist *l,int k)
{
int i;
int flag=0;
for(i=0;i<=l->length-1;i++)
{
if(l->elem[i]==k)
{
printf("元素%d的位置是%d!\n",k,i+1);
flag++;
}
else
continue;
}
if(flag==0)
printf("線性表中不存在元素:%d!\n",k);
}

int cmp(int a,int b)
{
if(a>b)
return 1;
else
return 0;
}

//在線性表L中找第一個與e滿足compare關系的元素的位序。
void locateelem_sq(sqlist *l,int e, int (*compare)(int a,int b))
{
int i=1;
int flag=0;
for(i=1;i<=l->length;i++)
{
if(compare(l->elem[i-1],e))
{
printf("比%d大的元素的位序為:%d\n",e,i);
flag++;
}
else
continue;
}
if(flag==0)
printf("不存在比%d大的元素!\n",e);

}
void showmenu()
{
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");
printf(" * 選擇響應的操作 *\n");
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * **\n");
printf(" * *\n");
printf(" * [0] 顯 示 該 表 [99] 退 出 程 序 *\n");
printf(" * [1] 讀 取 元 素 [ 2] 插 入 元 素 [ 3] 刪 除 元 素 *\n");
printf(" * [ 4] 尋 找 前 驅 [ 5] 尋 找 後 繼 [ 6] 返 回 表 長 *\n");
printf(" * [ 7] 置 逆 操 作 [ 8] 合 並 兩 表 [ 9] 兩 表 並 集 *\n");
printf(" * [10] 判 空 [11] 清 空 [12]有序無重復元素 *\n");
printf(" * [13] 順 序 檢 索 [14] 尋 找 位 序 *\n");
printf(" * *\n");
printf(" * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\n");
}

void main()
{
int n,m,i,k,cure,select;
elemtype e, pre_e, next_e;
sqlist l,r,la,lb,lc;
printf("請輸入你要創建的線性表的長度:");
scanf("%d",&n);
printf("\n");
initlist_sq(&l,n);
printf("你創建的線性表如下:\n");
print_sq(&l);
while(1)
{
showmenu();
printf("請選擇響應的操作:");
scanf("%d",&select);
switch(select)
{
case 99:exit(1);
case 0:print_sq(&l);
break;
case 1:
printf("請輸入所取元素的位置:\n");
scanf("%d",&i);
if(getelem_sq(&l,i,&e)==1)
printf("線性表中第%d個元素為%d\n",i,e);
break;
case 2:
printf("請輸入要插入的位置:\n");
scanf("%d",&i);
printf("請輸入要插入的元素:\n");
scanf("%d",&cure);
listinsert_sq(&l,i,cure);
printf("插入操作完成後的線性表是:");
print_sq(&l);
break;
case 3:printf("你要刪除哪一個元素：\n");
scanf("%d",&i);
listdelete_sq(&l,i,&e);
printf("你刪除的第%d個元素是:%d\n",i,e);
printf("刪除操作完成後的線性表是:");
print_sq(&l);
break;
case 4:
printf("請輸入要尋找前驅結點的元素:\n");
scanf("%d",&cure);
priorelem_sq(&l,cure,&pre_e);

break;
case 5:
printf("請輸入一個元素以便尋找其後繼結點:\n");
scanf("%d",&cure);
nextelem_sq(&l,cure,&next_e);
break;
case 6:
printf("該線性表的長度是%d\n",listlength_sq(&l));
break;
case 7:
printf("置逆之前的線性表為：\n");
print_sq(&l);
convert_sq(&l);
printf("置逆之後的線性表為：\n");
print_sq(&l);
break;
case 8:printf("\n請輸入你要創建的線性表la的長度:");
scanf("%d",&n);
initlist_sq(&l,n);
printf("\n請輸入你要創建的線性表lb的長度:");
scanf("%d",&m);
initlist_sq(&r,m);
mergelist_sq(&l,&r,&lc);
printf("合並後的線性表為:\n");
print_sq(&lc);
break;
case 9:
printf("請輸入la的長度n:");
scanf("%d",&n);
initlist_sq(&la,n);
printf("請輸入lb的長度m:");
scanf("%d",&m);
initlist_sq(&lb,m);
unionl(&la,&lb);
printf("並集後的la為:\n");
print_sq(&la);
break;
case 10:
listempty_sq(&l);
break;
case 11:
clearlist_sq(&l);
break;
case 12:deld_sq(&l);
printf("\n修改為有序且無重復元素後的線性表為:");
printf("\n");
print_sq(&l);
break;
case 13:
printf("請輸入要查找的元素:");
scanf("%d",&k);
sqsearch(&l, k);
break;
case 14:
printf("請輸入一個數據元素:\n");
scanf("%d",&cure);
locateelem_sq(&l,cure,cmp);
break;
default:
printf("請選擇菜單中的操作,按99退出程序\n");
}
}
}

E. 用C語言編寫程序實現線性表的順序存儲結構並實現以下功能： 1. 輸入一組整數構造線性表；

比如你要在第i個元素之後插入，就把i+1直到最後一個元素依次向後移動一位，再把你要放的元素放到第i+1位置即可

F. 編一個程序實現線性表的順序存儲和鏈式存儲

以下是用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;
}

G. 數據結構實驗，線性表的順序存儲結構的實現

C++代碼編寫的

#include<iostream>
#include<string>
usingnamespacestd;
typedefintElemType;
typedefstructLNode
{
ElemTypedata;
structLNode*next;
}LinkList;
voidCreatListR(LinkList*&L,ElemTypea[],intn)
{
LinkList*s,*r;
inti;
//L=(LinkList*)malloc(sizeof(LinkList));
L=newLinkList();
r=L;
for(i=0;i<n;i++)
{
//s=(LinkList*)malloc(sizeof(LinkList));
s=newLinkList();
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}
voidDispList(LinkList*L)
{
LinkList*p=L->next;
while(p!=NULL)
{
cout<<p->data<<"";
p=p->next;
}
cout<<endl;
}
intListInsert(LinkList*&L,inti,ElemTypee)
{
intj=0;
LinkList*p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return0;
else
{
s=newLinkList();
s->data=e;
s->next=p->next;
p->next=s;
return1;
}
}
intListDelete(LinkList*&L,inti)
{
intj=0;
LinkList*p=L,*q;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
{
return0;
}
else
{
q=p->next;
if(q==NULL)
{
return0;
}
p->next=q->next;
inta=q->data;
free(q);
returna;
}
}
intmain()
{
LinkList*L,*L1;
inta[]={1,5,7,9,12,18,19,20,30,43,45,56,41,42,78};
intn=15,i,x,y,j;
CreatListR(L,a,n);
DispList(L);
cout<<"請輸入i"<<endl;
cin>>i;
cout<<"請輸入x"<<endl;
cin>>x;
ListInsert(L,i,x);
DispList(L);
cout<<"請輸入j"<<endl;
cin>>j;
y=ListDelete(L,j);
DispList(L);
cout<<y<<endl;
return0;
}

H. 數據結構試驗線性表的順序存儲結構是什麼

#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);

I. 線性表的順序存儲結構是一種什麼

線性表的鏈式存儲結構是一種順序存儲的存儲結構。

線性表的鏈式存儲結構中的每一個存儲結點不僅含有一個數據元素，還包括指針，每一個指針指向一個與本結點有邏輯關系的結點，此類存儲方式屬於順序存儲；線性表是最基本、最簡單、也是最常用的一種數據結構。線性表（linear list）是數據結構的一種，一個線性表是n個具有相同特性的數據元素的有限序列。

簡介

我們說「線性」和「非線性」，只在邏輯層次上討論，而不考慮存儲層次，所以雙向鏈表和循環鏈表依舊是線性表。

在數據結構邏輯層次上細分，線性表可分為一般線性表和受限線性表。一般線性表也就是我們通常所說的「線性表」，可以自由的刪除或添加結點。受限線性表主要包括棧和隊列，受限表示對結點的操作受限制。