线性表的顺序存储实验

❶ 数据结构实验（C语言）： 顺序表实验

//线性表函数操作
#include <stdio.h>
#include <string.h>

#define MaxSize 30
#define Error 0
#define True 1

typedef char ElemType;

typedef struct
{
ElemType elem[MaxSize];

int length;
}SqList; /*顺序表类型定义*/

void InitList(SqList * &L) /*初始化顺序表L*/
{
L = (SqList *)malloc(sizeof(SqList));
L -> length = 0;
}

void DestroyList( SqList *L ) /*释放顺序表L*/
{
free(L);
}

int ListEmpty( SqList *L ) /*判断顺序表L是否为空表*/
{
return( L -> length == 0);
}

int ListLength( SqList *L ) /*返回顺序表L的元素个数*/
{
return( L -> length);
}

void DispList( SqList *L ) /*输出顺序表L*/
{
int i;
if( ListEmpty(L))
return;
for( i = 0; i < L -> length; i++ )
printf("%c", L -> elem[i]);
printf("\n");
}

int GetElem( SqList *L, int i, ElemType &e) /*获取顺序表中的第i个元素*/
{
if( i < 1 || i > L -> elem[i])
return Error;
e = L -> elem[i - 1];
return True;
}

int LocateElem( SqList *L, ElemType e) /*在顺序表中查找元素e*/
{
int i = 0;
while( i < L -> length && L -> elem[i] != e)
i++;
if(i >= L -> length)
return Error;
else
return i+1;
}

int ListInsert( SqList * &L, int i, ElemType e) /*在顺序表L中第i个位置插入元素e*/
{
int j;
if( i < 1 || i > L -> length + 1)
return 0;
i--; /*将顺序表位序转化为elem下标*/
for( j = L -> length; j > i; j--) /*将elem[i]及后面元素后移一个位置*/
L -> elem[j] = L -> elem[j - 1];
L -> elem[i] = e;
L -> length++; /*顺序表长度增1*/
return True;
}

int ListDelete( SqList * &L, int i, ElemType &e) /*顺序表L中删除第i个元素*/
{
int j;
if( i < 1 || i > L -> length)
return Error;
i--; /*将顺序表位序转化为elem下标*/
e = L -> elem[i];
for(j = i; j < L -> length - i; j++)
L -> elem[j] = L -> elem[j + 1];
L -> length--; /*顺序表长度减1*/
return True;
}

void main()
{
SqList *L;
ElemType e;
printf("(1)初始化顺序表L\n");
InitList(L);
printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
ListInsert(L, 1, 'a');
ListInsert(L, 2, 'b');
ListInsert(L, 3, 'c');
ListInsert(L, 4, 'd');
ListInsert(L, 5, 'e');
printf("(3)输出顺序表L:");
DispList(L);
printf("(4)顺序表L长度 = %d\n", ListLength(L));
printf("(5)顺序表L为%s\n", (ListEmpty(L) ?"空" :"非空"));
GetElem(L, 3, e);
printf("(6)顺序表L的第3个元素 = %c\n", e);
printf("(7)元素a的位置 = %d\n", LocateElem(L,'a'));
printf("(8)在第4个元素位置上插入f元素\n");
ListInsert(L, 4, 'f');
printf("(9)输出新的顺序表L:");
DispList(L);
printf("(10)删除L的第3个元素\n");
ListDelete(L, 3, e);
printf("(11)输出新的顺序表L:");
DispList(L);
printf("(12)释放顺序表L\n");
DestroyList(L);

}

❷ 顺序表的基本操作实验总结

顺序表的基本操作实验总结：

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，

即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构。采用顺序存储结构的线性表简称为“ 顺序表”。顺序表的存储特点是：只要确定了起始位置，表中任一元素的地址都通过下列公式得到：LOC（ai）=LOC（a1）+（i-1）*L 1≤i≤n

其中，L是元素占用存储单元的长度。如顺序表的每个结点占用len个内存单元，用location (ki)表示顺序表中第i个结点ki所占内存空间的第1个单元的地址。则有如下的关系:location (ki+1) = location (ki) +len

❸ 线性表的顺序存储实验

你改下下面代码的标点就行了：
#include<iostream.h>
#define elemtype int
struct link
{ elemtype data；//元素类型
link *next； //指针类型，存放下一个元素地址
};

//头插法建立带头结点的单链表
link *hcreat()
{ link s,p;
elemtype i;
cout<<”输入多个结点数值(用空格分隔)，为0时算法结束”；
cin>>i；
p=new link；
p->next=NULL；
while(i) //当输入的数据不为0时，循环建单链表
{s=new link；
s->data=i；
s->next=p->next；
p->next=s；
cin>>i； }
return p；
}

//输出单链表
void print(1ink *head)
{
1ink *p；
p=head->next；
while(p->next!=NULL)
{
cout<<p->data<<”->”； //输出表中非最后一个元素
p=p->next；
}
cout<<p->data； //输出表中最后一个元素
cout<<endl；
}

∥在单链表head中查找值为x的结点
Link *Locate(1ink *head，elemtype x)
{
Link *p；
p=head->next；
while((p!=NULL)&&(p->data!=x))
p=p->next；
return p； }

//在head为头指针的单链表中，删除值为x的结点
void deletel(1ink *head，elemtype x)
{
1ink *p， *q；
q=head；
p=head->next；
while((p!=NULL)&&(p->data!=x))
{
q=p；
p=p->next；}
If(p==NULL) cout<<“要删除的结点不存在”；
else
q->next=p ->next；
delete(p)；
}
}
//在头指针head所指的单链表中，在值为x的结点之后插入值为y的结点
void insert(1ink *head，elemtype x，elemtype y)
｛ link *p， *s；
s=new link；
s->data=y；
if(head->next==NULL) //链表为空
{
head->next=s；
s->next=NULL：
}
p=Locate(head，x)；//调用查找算法 ‘
if(p==NULL)
cout<<”插入位置非法”：
else
(s->next=p->next；
p->next=s；
}
}

//将单链表p中所有值为x的元素修改成y
void change(1ink *p,elemtype x,elemtype y)
{
link *q；
q=p->next；
while(q!=NULL)
{ if(q->data==x) q->data=y；
q=q->next；
}
}

void count(1ink *h) //统计单链表中结点个数
{
1ink *p；int n=0；
p=h->next；
while(p!=NULL)
{n++；p=p->next；}
return n;
}


void main()
{ int n；
elemtype x，y；
link *p， *q；
p=hcreat()； //头插法建立链表
print(p)； //输出刚建立的单链表
cout<<”请输入要删除的元素”；
cin>>y；
deletel(p，y)；
print(p)； //输出删除后的结果
cout<<”请输入插入位置的元素值(将待插元素插入到它的后面)”;
cin>>x；
cout<<”请输入待插元素值”；
cin>>y；
insert(p，x，y)；
print(p)； //输出插入后的结果
cout<<”请输入要修改前、后的元素值”;
cin>>x>>y；
change(p，x，y)；
print(p)；
cout<<”请输入要查找的元素值”；
cin>>x；
q=Locate(p，x)；
if(q==NULL)cout<<x<<”不在表中，找不到!”<<endl；
else cout<<x<<”在表中，已找到!”<<endl；
n=count(p)；
cout<<”链表中结点个数为：”<<n<<endl：
}

❹ 数据结构实验:线性表顺序存储和链式存储（简单链表）插入、删除运算

#include <iostream.h>
#include <iomanip.h>

typedef struct Lnode
{
int data;
struct Lnode *next;
}LNode,*LinkList;

void CreateList1(LinkList &L,int n);//insert from head
void CreateList2(LinkList &L,int n);//insert from tail
void CreateList3(LinkList &L,int n);//insert by sorting number
void InsertList(LinkList L);
void DeleteList(LinkList L,int num);
void ShowList(LinkList L);
void FreeList(LinkList L);

void main()
{
LinkList H;
int num;
/*
//reverse order input
cout<<"Input the length of list:"<<endl;
cin>>num;
CreateList1(H,num);
cout<<"The List is:";
ShowList(H);
FreeList(H);*/
cout<<"Input the length of list:"<<endl;
cin>>num;
CreateList3(H,num);
cout<<"The List is:";
ShowList(H);
/*InsertList(H);
cout<<"The new List is:";
ShowList(H);
cout<<"the delete data:";
cin>>num;
DeleteList(H,num);
cout<<"The new List is:";
ShowList(H);*/
FreeList(H);
}
//insert from the head of list when creating

void CreateList1(LinkList &L,int n)
{
LinkList p;
int i;
L=new LNode;
L->next =NULL;
cout<<"input the data of list (in reverse order)!"<<endl ;
for(i=0;i<n;i++)
{
p=new LNode;
cin>>p->data;
p->next=L->next;
L->next =p;
}
}
//insert from the tail of list when creating
void CreateList2(LinkList &L,int n)
{
LinkList p;
int i;
L=new LNode;
L->next =NULL;
LinkList head=L;
cout<<"input the data of list (in order)!"<<endl ;
for(i=0;i<n;i++)
{
p=new LNode;
cin>>p->data;
head->next=p;
p->next=NULL;
head=head->next;
}
}
//insert List by sorting number
void CreateList3(LinkList &L,int n){
LinkList p,q;
L=new LNode;
L->next =NULL;
cout<<"input the data of list (It can autoorder from small to big)!"<<endl ;
for(int i=0;i<n;i++)
{
q=L;
p=new LNode;
cin>>p->data;
while((q->next!=NULL)&&(p->data>q->next->data)){//be careful for condition
//from the condition,we can know runing principle for "&&"
q=q->next;
}
p->next=q->next;
q->next =p;
}

}
void ShowList(LinkList L)
{
LinkList p;

for(p=L->next; p;p=p->next)
cout<<setw(5)<<p->data<<" ";
cout<<endl;
}
//insert data from tail
void InsertList(LinkList L){
LinkList p=L,q;
q=new LNode;
cout<<"input the inserting number :";
cin>>q->data;
while(p->next){
p=p->next;
}
p->next=q;
q->next=NULL;
}
//delete data(all input data)
void DeleteList(LinkList L,int data){
LinkList p=L,q;
while(p->next){
q=p ;
p=p->next;
if(p->data==data){
q->next=p->next;
}
}
}

void FreeList(LinkList L)
{
LinkList p=L->next ;
while(p)
{
delete L;
L=p;
p=p->next;
}
}

满足你所有的要求了
只是要自己去掉一些//

❺ 数据结构实验 线性表中顺序存储结构的基本操作算法（建顺序表，查询，插入，删除，遍历）

有序线性表插入一个数依然有序
#include<stdio.h>
#define MAXSIZE 6
typedef char datatype;
typedef struct SeqList
{
datatypedata[MAXSIZE];
int last;
}SeqList;

SeqList *init_SeqList()
{
SeqList *L;
L=(SeqList*)malloc(sizeof(SeqList));
L->last=-1;
return L;
}

int main()
{ SeqList *L;
int k,x,j;
intInser_SeqList(SeqList *L);
L->last=0;
L=init_SeqList();
for(k=0;k<(MAXSIZE-1);k++)
{ scanf("%d",&x);
L->data[k]=x;
L->last++;
}
Inser_SeqList(L);
for(j=0;j<L->last;j++)
printf("%d",L->data[j]);

return 0;
}
int Inser_SeqList(SeqList *L)
{
int j,x;
if(L->last==MAXSIZE-1)
{printf("表满");
return (-1);
}

L->last++;
for(j=L->last;j>=0;j--)
if(L->data[j]<x)
L->data[L->last]=x;
else
L->data[j+1]=L->data[j];

return 1;
}
你好，上面是我的程序：符合你的1 2 4点 查询、删除操作在课本里找到 写入即可 谢谢

❻ 数据结构实验，线性表的顺序存储结构的实现

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

❼ 求数据结构试验 线性表的顺序存储结构

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