❶ 實驗一 順序表的基本運算 一． 實驗目的： 掌握線性表在順序存儲結構上的插入、刪除運算。 二． 實驗要求
問老師吧 少年
❷ 求數據結構試驗 線性表的順序存儲結構
#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);
}