❶ 实验一 顺序表的基本运算 一． 实验目的： 掌握线性表在顺序存储结构上的插入、删除运算。 二． 实验要求
问老师吧 少年
❷ 求数据结构试验 线性表的顺序存储结构
#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);
❸ 数据结构实验:线性表顺序存储和链式存储（简单链表）插入、删除运算
#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;
}
}
满足你所有的要求了
只是要自己去掉一些//
❹ 线性表的顺序存储结构设计对程序设计有何启示
连续的空间来存储数据，可以直接以下标方式访问数据，时间复杂度为O(1)；
当插入或删除数据时，需要移动数据，时间复杂度为O(n)。
如果数据查询的使用频率远远高于数据插入或删除的频率，顺序表是一个效率高的存储结构。
❺ 求救 急急急 数据结构 【实验目的】 （1）掌握线性表的特点 （2）掌握线性表顺序存储结构和
题主你问的这个真心懒得写 原因如下
显然是作业 而且题主你一点都没有试着解过
代码很长
很无聊的问题
综上，以后不要问类似的问题了
❻ 算法与数据结构实验顺序表的应用实验报告
者visual c++都行。
看看这个也许你会明白的更多一些。
实验一 多项式相加
一、实验目的
熟悉链表的使用。
掌握如何使用C语言实现链表的说明、创建以及结点的插入和删除等操作。
二、实验要求
熟悉C语言编程。
三、实验内容
对于两个一元多项式中所有指数相同的项，对应系数相加，若其和不为零，则构成“和多项式”的一项；对于两个一元多项式中所有指数不相同的项，则分别复抄到“和多项式”中去。
四、实验步骤
1. 用链表作一元多项式的数据结构，用C语言对链表作说明
2. 生成输入一元多项式的函数
3. 输入一元多项式A(x)和B(x)
4. 以一元多项式A(x)为和多项式，将B(x)多项式中系数加入到A(x)中去
实验二 后缀表达式计算
一、实验目的
熟悉栈的使用。
掌握如何使用C语言实现栈的说明、创建以及进栈和出栈等操作。
二、实验要求
熟悉C语言编程。
三、实验内容
先将中缀表达式（就是我们通常所见的）转换为后缀表达式，比如 a+b*c+d 要变成 abc*+d+；转换的方法用栈来实现，涉及到运算符的优先级；然后用另一个栈来对后缀表达式计算结果
四、实验步骤
1．读入字母/数字--〉字母/数字进栈
2．读入运算符--〉退出两个字母/数字，用运算符计算结果，并将结果进栈
3．栈能刚好退完，则最后的即为结果。否则表明表达式有误
实验三 Kmp算法
一、实验目的
熟悉字符串的使用。
掌握如何kmp算法实验字符串的模式匹配。
二、实验要求
熟悉C语言编程。
三、实验内容
求出子串（模式串）的next，利用kmp算法实验模式与主串的匹配算法。
四、实验步骤
1．生成模式串的next函数
2．从第1个字符开始，进行模式串与主串的比较，
3．如果出现失配，将模式串的第next[j]位置开始，继续与主串进行比较。
实验四 Huffman 编码
一、实验目的
熟悉Huffman编码方法。
了解并弄懂Huffman编码实现信息的无损压缩原理。
二、实验要求
熟悉C语言编程。
三、实验内容
1.根据给定的n个权值(w1, w2, …, wn)构成n棵二叉树的集合F=，其中每棵二叉树Ti中只有一个带树为Ti的根结点
2.在F中选取两棵根结点的权值最小的树作为左右子树构造一棵新的二叉树，且置其根结点的权值为其左右子树权值之和
3.在F中删除这两棵树，同时将新得到的二叉树加入F中
4.重复2, 3，直到F只含一棵树为止
四、实验步骤
1．用C语言实现二叉树的说明
2．输入n个权值，并生成n个二叉树
3．对n个二叉树逐步生成Huffman树
4．对Huffman树的每个叶子结点生成编码
实验五 关键路径
一、实验目的
熟悉关键路径的实现方法。
了解AOE-网以及关键路径在工程实践中的应用。
二、实验要求
熟悉C语言编程。
三、实验内容
根据输入的弧，生成AOE-网。从始点开始，找出到终点的多条路径，求这些路径上的关键活动。由关键活动组成的从始点到终点的路径，即为关键路径。
四、实验步骤
1．输入e条弧，生成AOE-网的存储结构。
2．从始点v0出发，令ve[0]=0，按拓扑有序求ve[j]
3．从终点vn-1出发，令vl[n-1]=ve[n-1]，按逆拓扑有序求vl[i]
4．根据各顶点的ve和vl值，求每条弧(活动)ai的最早开始时间e[ai]和最迟开始时间l[ai]
5．如果e[ai]=l[ai]，则ai为关键活动
实验六 最短路经
一、实验目的
熟悉最短路径的实现方法。
了解AOE-网以及最短路径在求解实际问题中的应用。
二、实验要求
熟悉C语言编程。
三、实验内容
从始点v0开始，逐步求v0到其它可达的各顶点的最短路径，直到所有顶点计算完成为止。
四、实验步骤
1．输入e条弧，生成AOE-网的存储结构。
2．初始化： S ← ;
dist[j] ← Edge[0][j], j = 1, 2, …, n-1; // n为图中顶点个数
3.求出最短路径的长度：
dist[k] ← min , i V- S ;
S ← S U ;
4.修改从v0到V-S集合中各顶点的最短路径：
dist[i] ← min,
对于每一个 i 属于 V- S ;
5.判断：若 S = V, 则算法结束，否则转 2。
实验七 二叉排序树
一、实验目的
熟悉二叉排序树的使用。
掌握如何使用C语言实现二叉树的说明、创建以及二叉排序树的生成等操作。
二、实验要求
熟悉C语言编程。
三、实验内容
给定一个记录关键字的值，与二叉排序树的根结点值比较，如果小于根结点的值，则向左子树查找；如果大于根结点的值，则向右子树查找。如果查找到叶子结点leaf，仍没有找到记录，则：如果关键字的值小于leaf的值，则插入该leaf结点的左边，做leaf的左孩子，否则做leaf的右孩子。
四、实验步骤
1．用C语言实现二叉树的说明
2．直接将输入的值作为根结点的值
3．与根结点比较，小于则放到左子树上，大于则放到右子树上。
实验八 希尔排序
一、实验目的
熟悉希尔排序的使用。
掌握如何使用C语言实现若干记录的排序。
二、实验要求
熟悉C语言编程。
三、实验内容
先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
四、实验步骤
1．输入待排序记录
2．首先取一个整数 gap < n(待排序记录数) 作为间隔, 将全部记录分为 gap 个子序列, 所有距离为 gap 的记录放在同一个子序列中
3．在每一个子序列中分别施行直接插入排序。
4．然后缩小间隔 gap, 例如取 gap = gap/2
5．重复上述的子序列划分和排序工作，直到最后取gap = 1, 将所有记录放在同一个序列中排序为止。
实验九 快速排序
一、实验目的
熟悉快速排序的使用。
掌握如何使用C语言实现若干记录的排序。
二、实验要求
熟悉C语言编程。
三、实验内容
通过一趟将待排记录分割成独立的两个部分，其中一部分记录的关键字均比另一部分记录的关键字小。再对两个部分分别进行快速排序。
四、实验步骤
1．输入待排序的记录，并选择第一个记录作为pivotkey记录
2.从high指向的记录开始,向前找到第一个关键字的值小于Pivotkey的记录,将其放到low指向的位置,low+1
3.从low指向的记录开始,向后找到第一个关键字的值大于Pivotkey的记录,将其放到high指向的位置,high-1
4.重复2,3，直到low=high，将枢轴记录放在low(high)指向的位置
5．重复2,3,4，直到整个记录有序为止
实验十 堆排序
一、实验目的
熟悉堆排序的使用。
掌握如何使用C语言实现若干记录的排序。
二、实验要求
熟悉C语言编程。
三、实验内容
首先将一个无序序列建成一个堆；然后输出堆顶元素；在输出堆顶元素之后，调整剩余的元素成为一个新堆。
四、实验步骤
1．输入记录，按顺序创建一个完全二叉树
2．根据筛选算法，从最后一个结点开始，一直到根结点，逐步筛选，建造初始堆。
3．输出堆顶记录，将最后一个结点放到堆顶，并做筛选，重新建造一个堆
4．直到所有记录输出为止
❼ 数据结构完整版实验报告
(一)实验目的和要求
实验目的：熟练掌握线性表的基本操作在顺序存储结构上的实现。
实验要求：任选一种高级程序语言编写源程序，并调试通过，测试正确。
(二)实验主要内容
1. 建立n个元素的顺序表SqList，实现顺序表的基本操作；
2. 在SqList的元素i之后插入一个元素，实现顺序表插入的基本操作；
3. 在sqList中删除指定位置i上的元素，实现顺序表删除的操作。
4.
(三)主要仪器设备
PC机，Windows XP操作平台，Visual C++
(四)实验原理
顺序表操作：定义一个顺序表类，该类包括顺序表的存储空间、存储容量和长度，以及构造、插入、删除、遍历等操作的方法
(五)实验步骤与调试分析：
顺序表操作：先构造有四个数据的顺序表，在第4个位置插入9，再读取并删除第3个元素。
(六)实验结果与分析：
顺序表操作：
（七）附录（源程序）：
#include<iostream>
using namespace std;
const int LIST_INIT_SIZE=10; //顺序表初始长度
const int LISTINCREMENT=5; //顺序表长度增值
class SqList
{
int *L; //定义存储空间起始地址
int length; //顺序表当前长度
int listsize; //顺序表当前存储容量
bool flag; //设立标志值记录操作成败
public:
SqList(int v1,int v2,int v3,int v4); //构造函数构造并初始化顺序表
void ListInsert(int i,int e); //实现将e插入到顺序表中第i个位置
void ListDelete(int i,int &e); //实现删除顺序表第i个元素
void ListVisit(); //实现顺序表的遍历
};
SqList::SqList(int v1,int v2,int v3,int v4) //构造并初始化顺序表
{
L=new int[LIST_INIT_SIZE];
if(!L) //分配失败
{
flag=false;
cout<<"ERROR"<<endl;
}
else //分配成功，进行初始化
{
*L=v1;
*(L+1)=v2;
*(L+2)=v3;
*(L+3)=v4;
length=4;
listsize=LIST_INIT_SIZE;
flag=true;
}
}
void SqList::ListInsert(int i,int e) //插入元素
{
int *p,*q;
int t;
if(i<1||i>length+1) cout<<"ERROR"<<endl; //插入位置错误
else
{
if(length==listsize) //空间不足，增加分配
{
p=new int[listsize+LISTINCREMENT];
if(!p) cout<<"ERROR"<<endl; //分配失败
else //分配成功，复制顺序表
{
for(t=0;t<length;t++)
*(p+t)=*(L+t);
q=L;L=p;p=q;
delete q;
listsize+=LISTINCREMENT;
}
}
for(t=length;t>=i;t--)
*(L+length)=*(L+length-1);
*(L+i-1)=e;
length++; //插入成功，表长加1
}
}
void SqList::ListDelete(int i,int &e)
{
if(i<1||i>length) cout<<"ERROR"<<endl; //删除位置错误
else
{
e=*(L+i-1);
while(i<length)
{
*(L+i-1)=*(L+i);
i++;
}
length--; //删除成功表长减1
}
}
void SqList::ListVisit() //遍历
{
int i;
for(i=0;i<length;i++)
cout<<" "<<*(L+i);
cout<<endl;
}
int main()
{
int e=0;
SqList list(2,3,4,5);
list.ListVisit();
list.ListInsert(4,9);
list.ListVisit();
list.ListDelete(3,e);
list.ListVisit();
cout<<"e="<<e<<endl;
return 0;
}
❽ 数据结构实验 线性表中顺序存储结构的基本操作算法（建顺序表，查询，插入，删除，遍历）
有序线性表插入一个数依然有序
#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 <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);
}