线性表的顺序存储结构源码

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个具有相同特性的数据元素的有限序列。

简介

我们说“线性”和“非线性”，只在逻辑层次上讨论，而不考虑存储层次，所以双向链表和循环链表依旧是线性表。

在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。一般线性表也就是我们通常所说的“线性表”，可以自由的删除或添加结点。受限线性表主要包括栈和队列，受限表示对结点的操作受限制。