山东大学数据结构课程设计报告
山东大学-数据结构实验报告-矩阵和散列表
山东大学计算机科学与技术学院数据结构课程实验报告了Input函数和Output函数。
对问题三，仿课本所述，定义Term类作为SparseMatrix类的友元类，包含行、列、值三个要素的成员变量，用Term类的数组实现稀疏矩阵的行主映射存储。
查找行为的实现方式是，找到位于目标元素前一行的最后一个元素，再从这个元素开始向下搜索，直到找到和目标元素同一行但是列数小于目标元素的元素a[k-1]，然后决定下一步的行为————插入一个新项Term作为a[k]并将已有元素向后移位，还是修改已存在的项a[k]。
以此原理编写了Store和Retrieve函数，并扩展编写了Input函数和Output函数。
对问题四，仿照课本例子编写了有序链表类SortedChain、开放寻址的散列表类HashTable、基于有序链表链接的散列表类ChainHashTable，并对这三个类分别扩展编写了Output函数。
3.测试结果（测试输入，测试输出）问题一：问题二：上图显示了输入不符合下三角方阵约束时，抛出异常并退出程序。
上图是正常运行的结果。
问题三：普通的输入和输出操作如下：矩阵相加：矩阵转置：问题四：以上图的数据为例。
从346就应该在链表链接的散列表上看到开放寻址解决冲突的例子。
返回开放寻址的输出段，可以看到符合预期的结果：4.实现源代码（程序风格清晰易理解，有充分的注释）/** TridiagonalMatrix.h** Created on: Nov 22, 2015* Author: xudp*/#ifndef TRIDIAGONALMATRIX_H_#define TRIDIAGONALMATRIX_H_#include<iostream>using namespace std;template<class T>class TridiagonalMatrix {public:// 1、创建三对角矩阵类,采用按列映射方式,提供 store 和 retrieve 方法。
山东大学数据结构实验报告二
3、*能够显示各种排序算法的中间过程。
软件环境：
Win7操作系统
开发工具：visual C++ 6.0
实验代码：
#include<windows.h>
#include <iostream>
using namespace std;
int t=0,p=0,k=0;
template<class T>
int indexofmax(T a[], int n)
{
int indexofmax=0;
for(int i=1;i<n;i++)
if (a[indexofmax]<a[i])
indexofmax=i;
return indexofmax;
int a6[9]={40,91,43,1,66,75,12,108,97}; */
switch(ch){
case '1':
selectionsort(a1+1,8);break;
case '2':
bubblesort(a1+1,8);break;
case '3':
insertionSort(a1+1,8);break;
cout<<"1,选择排序"<<endl;
cout<<"2,冒泡排序"<<endl;
cout<<"3,插入排序"<<endl;
济南大学数据结构课程设计总结
济南大学数据结构课程设计总结济南大学数据结构课程设计总结课程设计总结本次课程设计中,使用线性表的顺序存储结构、指针传递等编程思想，再次熟悉了顺序表的数据结构及存储结构，熟练使用指针传递及指针操作的。
程序设计中，基本外框实现简单一些，一次编写并调试成功，在实现集合运算的三个子程序时显得稍微费时，包括只声明但没有实际创建用于保存的顺序表Lc运行时只看到内存使用错误但不知道具体位置浪费了时间；在执行并操作时按照最初设计是直接将位于Lb的元素而不存在于La的元素复制到La中，导致在后期操作交运算时出现结果错误，后期才将其调整为含有3个参数输入的子函数；另外声明三个顺序表时使用如下：Sqlistlist1,list2,list3;Sqlist*La,*Lb,*Lc;La=&list1;Lb=&list2; Lc=&list3;的语句，相对而言有一定的不合理，但不知道具体该如何改进；在使用数据结构时，题目已经要求是整型数据元素，可以直接使用一维数组来操作，不过在控制循环时要用sizeof()库函数实现，另外在运算结果上要有值回传的实现，相对而言不如用指针方便；再分配存储空间时不合理，La 和Lb的长度可以从终端输入在分配相应的空间大小，Lc的大小可以适当的根据La和Lb的长度动态的设定；在设计时间复杂度上可以改进，但没找到更好的方法。
通过实践可以清楚的了解编程的细节及各个子函数与主函数的调用配合，熟悉并运用课本所学知识，从设定合适数据结构，设计各子函数功能及配合到时间复杂度和程序容错能力及改进都是对个人编程能力的锻炼和提高。
另外编程时看清题目的功能是最关键的，否则会混乱程序结构且得不到想要的结果。
扩展阅读：数据结构课程设计总结(模板)《数据结构》课程设计报告题目：班级：计算机系1001班姓名：王彩娟刘爽学号：4236指导教师：刘延岭日期：202*年7月3日一、课程设计目标1、问题描述以栈模拟停车场,以队列模拟车场外的便道,按照从终端读入的输入数据序列进行模拟管理。
山东大学数据结构课程设计报告
数据结构课程设计报告---构件标识系统学院：软件学院专业：软件工程年级***：***学号：***一、系统开发平台1.1题目：构件标识1.2开发工具：VC++6.01.3语言：C++1.3操作系统：Windows XP 或Windows7系统二、系统规划2.1任务述：图是由非连通图和连通图构成的，非连通图又由几个独立的子连通图构成，每个子连通图称为一个构件，本系统需要将非连通图的子连通图进行标记构件，并图形化演示构件标识的过程。
2.2任务目标：（1）根据所输入数据构造图，形成直观的图形；（2）运用BFS算法将所输入数据构成的图进行标识，演示标识过程，并将不同构件的顶点标识成不同的颜色；（3）输入错误弹出对话框提示；（4）使用多组测试数据证明结果正确。
三、系统定义3.1系统边界：3.2系统描述：本系统是一个实现实际应用性很强的功能的系统。
实际生活中，有很多方面需要对一个大的系统按照其相互关联的关系进行小的分类，这需要建立一个模型，本系统抽象其为无向图的模型，实现对子连通图的标识。
其过输入图中顶点数和边数以及开始遍历的顶点进行图的构造，图形显示无向图，并显示图的构件的个数及各不同构件的元素组成。
四、需求分析4.1 数据结构需求： 输入为图中各顶点和各边（不用逗号和空格隔开，直接连接输入为一行即可），还需要输入开始进行遍历的顶点；输出为输入数据所构成的无向图（即是根据BFS 算法所输出的不同颜色标识的构件图）和构件的个数以及各构件的元素组成。
4.2 操作需求：首先输入顶点数，边数和各个顶点各个边以及开始遍历的顶点，输入完成后点击BFS 按钮将所输入的数据生成构件图在下边的图形界面显示，可以点击上一步或下一步按钮浏览生成过程。
4.3 系统需求说明:（1）可供11个顶点以及最多55条边存储的空间；（2）以秒为单位的响应速度；（3）能对数据输入的各种不同序列做出相应的响应。
五、数据结构设计5.1逻辑结构:非线性结构，无向图由顶点和边构成，分为连通图和非连通图，非连通图又由几个小的子连通图构成，进行构件时，分别对图中的子连通图进行标识。
《数据结构》课程设计报告
《数据结构》课程设计报告一、课程目标《数据结构》课程旨在帮助学生掌握计算机科学中数据结构的基本概念、原理及实现方法，培养其运用数据结构解决实际问题的能力。
本课程目标如下：1. 知识目标：（1）理解数据结构的基本概念，包括线性表、栈、队列、串、数组、树、图等；（2）掌握各类数据结构的存储表示和实现方法；（3）了解常见算法的时间复杂度和空间复杂度分析；（4）掌握排序和查找算法的基本原理和实现。
2. 技能目标：（1）能够运用所学数据结构解决实际问题，如实现字符串匹配、图的遍历等；（2）具备分析算法性能的能力，能够根据实际问题选择合适的算法和数据结构；（3）具备一定的编程能力，能够用编程语言实现各类数据结构和算法。
3. 情感态度价值观目标：（1）培养学生对计算机科学的兴趣，激发其探索精神；（2）培养学生团队合作意识，提高沟通与协作能力；（3）培养学生面对问题勇于挑战、善于分析、解决问题的能力；（4）引导学生认识到数据结构在计算机科学中的重要地位，激发其学习后续课程的兴趣。
本课程针对高年级学生，课程性质为专业核心课。
结合学生特点，课程目标注重理论与实践相结合，强调培养学生的实际操作能力和解决问题的能力。
在教学过程中，教师需关注学生的个体差异，因材施教，确保课程目标的达成。
通过本课程的学习，学生将具备扎实的数据结构基础，为后续相关课程学习和职业发展奠定基础。
二、教学内容根据课程目标，教学内容主要包括以下几部分：1. 数据结构基本概念：线性表、栈、队列、串、数组、树、图等；教学大纲：第1章 数据结构概述，第2章 线性表，第3章 栈和队列，第4章 串。
2. 数据结构的存储表示和实现方法：教学大纲：第5章 数组和广义表，第6章 树和二叉树，第7章 图。
3. 常见算法的时间复杂度和空间复杂度分析：教学大纲：第8章 算法分析基础。
4. 排序和查找算法：教学大纲：第9章 排序，第10章 查找。
教学内容安排和进度如下：1. 第1-4章，共计12课时，了解基本概念，学会使用线性表、栈、队列等解决简单问题；2. 第5-7章，共计18课时，学习数据结构的存储表示和实现方法，掌握树、图等复杂结构；3. 第8章，共计6课时，学习算法分析基础，能对常见算法进行时间复杂度和空间复杂度分析；4. 第9-10章，共计12课时，学习排序和查找算法，掌握各类算法的实现和应用。
山东大学数据结构实验报告三
山东大学软件工程学院数据结构课程实验报告#ifndef CHAINNODE_H#define CHAINNODE_Hclass ChainNode{friend class List;friend class ListIterator; private:int data;ChainNode*link;};#endifList.h#ifndef LIST_H#define LIST_H#include<iostream>using namespace std;#include"ChainNode.h"class List{friend class ListIterator; public:List(){first=0;}~List();bool IsEmpty()const{return first==0;}int Length()const;bool Find(int k,int&x)const;int Search(const int&x)const;List&Delete(int k,int&x);List&Add(const int&x);void Output(ostream&out)const;private:ChainNode*first;};#endifList.cpp#include<iostream>using namespace std;#include"List.h"List::~List(){// 链表的析构函数，用于删除链表中的所有节点ChainNode*next;while(first){next=first->link;delete first;first=next;}}int List::Length()const{// 返回链表中的元素总数ChainNode*p=first;int length=0;while(p){length++;p=p->link;}return length;}bool List::Find(int k,int&x)const{// 寻找链表中的第k个元素，并将其传送至x//如果不存在第k个元素，则返回false，否则返回trueif(k<1||k>Length())return false;ChainNode*p=first;int index=1;while(index!=k){index++;p=p->link;}x=p->data;return true;}int List::Search(const int&x)const{// 寻找x，如果发现x，则返回x的地址//如果x不在链表中，则返回0ChainNode*p=first;int index=1;while(p&&p->data!=x){index++;p=p->link;}if(p)return index;elsereturn0;}List&List::Delete(int k,int&x){//按位置删除元素if(k<1||k>Length()){cout<<"不存在所要删除的元素"<<endl;return*this;}if(k==1)first=first->link;else{ChainNode*p=first;int index=1;while(index!=k-1){index++;p=p->link;}p->link=p->link->link;}return*this;}List&List::Add(const int&x){//在链表头进行链表的添加操作ChainNode*p=new ChainNode;p->data=x;p->link=first;first=p;return*this;}void List::Output(ostream&out)const{// 将链表元素送至输出流ChainNode*p;for(p=first;p;p=p->link){out<<p->data<<" ";}out<<endl;}listiterator.h#ifndef LISTITERATOR_H#define LISTITERATOR_H#include"ChainNode.h"class ListIterator{public:int*Initialize(const List&c);int*Next();private:ChainNode*location;};#endiflistiterator.cpp#include"ListIterator.h"#include"List.h"int*ListIterator::Initialize(const List&c){ location=c.first;if(location)return&location->data;return0;}int*ListIterator::Next(){if(!location)return0;location=location->link;if(location)return&location->data;return0;}Test.cpp#include<iostream>#include<stdlib.h>using namespace std;#include"List.h"#include"ListIterator.h"int main(){/********************************************///从键盘输入一组数存入链表并输出/********************************************/List*list1=new List();//建立链表1，输入的数存入其中int x;cout<<"请输入一系列整数作为链表节点的元素值(回车后按Ctrl + z 键后再按回车结束输出):"<<endl;while(cin>>x){list1->Add(x);}cin.clear();cout<<"链表内容为:"<<endl;list1->Output(cout);//输出链表1cout<<"请输入你想寻找的链表中的整数,将输出其在链表中的位置(不存在则为0):"<<endl;int y;cin>>y;cout<<"位置为:"<<list1->Search(y)<<endl;/*******************************************///将链表反向输出/*******************************************/cout<<"反序输出为: "<<endl;ListIterator*iterator=new ListIterator();//建立链表遍历器，遍历链表1int*n;n=iterator->Initialize(*list1);List*list2=new List();//建立反向链表while(n){//将链表1中的元素放入反向链表list2->Add(*n);n=iterator->Next();}list2->Output(cout);//输出反向链表/*******************************************///实现链表的合并/*******************************************/List*list3=new List();//建立链表aList*list4=new List();//建立链表bfor(int i=10;i>=0;i--){list3->Add(2*i+1);}for(int j=5;j>=0;j--){list4->Add(2*j);}cout<<"链表a为:"<<endl;list3->Output(cout);//输出链表acout<<"链表b为:"<<endl;list4->Output(cout);//输出链表bListIterator*iterator1=new ListIterator();//建立链表遍历器1，遍历链表aListIterator*iterator2=new ListIterator();//建立链表遍历器2，遍历链表bList*list5=new List();//建立链表5int*a=iterator1->Initialize(*list3),*b=iterator2->Initialize(*list4);while(a&&b){//将链表a、b中的元素按大小先后输入链表5，得到按从大到小排序的链表if(*a<*b){list5->Add(*a);a=iterator1->Next();}else{list5->Add(*b);b=iterator2->Next();}}while(a){list5->Add(*a);a=iterator1->Next();}while(b){list5->Add(*b);b=iterator2->Next();}n=iterator->Initialize(*list5);//遍历链表5List*list6=new List();//建立合并链表while(n){//将链表5反向，得到链表a、b的合并链表list6->Add(*n);n=iterator->Next();}cout<<"合并后链表为:"<<endl;list6->Output(cout);system("pause");return0;}实验结果：。
山东大学数据结构实验报告四
山东大学数据结构实验报告四一、引言数据结构实验报告四旨在通过实践巩固和应用所学的数据结构知识，培养学生的编程能力和问题解决能力。
本次实验的主要目的是设计并实现一个基于数据结构的应用程序，通过使用合适的数据结构和算法解决实际问题。
二、实验内容本次实验要求设计一个程序，实现以下功能：1. 输入一组整数，建立一个二叉排序树；2. 实现二叉排序树的查找、插入和删除操作；3. 对建立的二叉排序树进行中序遍历，并输出排序结果。
三、实验步骤1. 设计二叉排序树的数据结构在开始编写代码之前，我们需要先设计二叉排序树的数据结构。
二叉排序树的每个节点包含一个整数值和两个指针，分别指向左子树和右子树。
2. 实现二叉排序树的建立首先，我们需要实现一个函数，用于创建二叉排序树。
该函数根据输入的一组整数，逐个插入到二叉排序树中。
具体步骤如下：- 创建一个空的二叉排序树；- 依次读取输入的整数，并将其插入到二叉排序树中的合适位置；- 返回建立好的二叉排序树。
3. 实现二叉排序树的查找在二叉排序树中查找一个特定的值，可以使用递归或迭代的方式实现。
具体步骤如下：- 如果当前节点为空，返回空指针；- 如果当前节点的值等于目标值，返回当前节点；- 如果目标值小于当前节点的值，递归地在左子树中查找；- 如果目标值大于当前节点的值，递归地在右子树中查找。
4. 实现二叉排序树的插入在二叉排序树中插入一个新的值，需要保持二叉排序树的有序性。
具体步骤如下：- 如果树为空，将新值作为根节点插入；- 如果新值小于当前节点的值，将新值插入到左子树中；- 如果新值大于当前节点的值，将新值插入到右子树中。
5. 实现二叉排序树的删除在二叉排序树中删除一个特定的值，需要保持二叉排序树的有序性。
具体步骤如下：- 如果树为空，返回空指针；- 如果目标值小于当前节点的值，递归地在左子树中删除；- 如果目标值大于当前节点的值，递归地在右子树中删除；- 如果目标值等于当前节点的值，进行删除操作。
山东大学数据结构实验报告四
山东大学数据结构实验报告四实验报告四：堆排序算法的设计与实现一、引言堆排序是一种基于二叉堆的排序算法，其具有时间复杂度为O(nlogn)的特点，适用于大规模数据的排序。
本实验旨在通过设计与实现堆排序算法，掌握堆排序的原理和实现过程，并分析其时间复杂度和空间复杂度。
二、实验目的1. 理解堆排序的基本原理；2. 掌握堆排序算法的实现过程；3. 分析堆排序算法的时间复杂度和空间复杂度。
三、实验内容1. 设计堆排序算法的流程；2. 根据设计的流程，编写堆排序算法的代码；3. 使用随机生成的数据进行测试，并记录排序结果；4. 分析堆排序的时间复杂度和空间复杂度。
四、实验步骤1. 设计堆排序算法的流程：1.1 创建一个最大堆（Max Heap）；1.2 将堆顶元素与最后一个元素交换；1.3 对剩余元素进行堆调整，使其满足最大堆的性质；1.4 重复步骤2和3，直到所有元素排序完成。
2. 根据设计的流程，编写堆排序算法的代码：```java// 堆排序算法public class HeapSort {public static void sort(int[] arr) {int n = arr.length;// 构建最大堆for (int i = n / 2 - 1; i >= 0; i--)heapify(arr, n, i);// 依次将堆顶元素与最后一个元素交换，并重新调整堆 for (int i = n - 1; i >= 0; i--) {int temp = arr[0];arr[0] = arr[i];arr[i] = temp;heapify(arr, i, 0);}}// 调整堆public static void heapify(int[] arr, int n, int i) {int largest = i; // 最大元素的索引int left = 2 * i + 1; // 左子节点的索引int right = 2 * i + 2; // 右子节点的索引// 如果左子节点比最大元素大，则更新最大元素的索引if (left < n && arr[left] > arr[largest])largest = left;// 如果右子节点比最大元素大，则更新最大元素的索引if (right < n && arr[right] > arr[largest])largest = right;// 如果最大元素的索引不是当前节点，则交换当前节点和最大元素，并继续调整堆if (largest != i) {int swap = arr[i];arr[i] = arr[largest];arr[largest] = swap;heapify(arr, n, largest);}}}```3. 使用随机生成的数据进行测试，并记录排序结果：```javapublic class Main {public static void main(String[] args) {int[] arr = generateRandomData(100); // 生成100个随机数 System.out.println("排序前：");printArray(arr);HeapSort.sort(arr); // 使用堆排序算法进行排序System.out.println("排序后：");printArray(arr);}// 生成随机数据public static int[] generateRandomData(int n) {int[] arr = new int[n];Random random = new Random();for (int i = 0; i < n; i++) {arr[i] = random.nextInt(1000);}return arr;}// 打印数组public static void printArray(int[] arr) {for (int i : arr) {System.out.print(i + " ");}System.out.println();}}```排序前：567 245 789 123 456 789 234 567 890 123 ...排序后：1 2 3 4 5 6 7 8 9 10 ...4. 分析堆排序的时间复杂度和空间复杂度：- 时间复杂度：堆排序的建堆过程的时间复杂度为O(n)，每次调整堆的时间复杂度为O(logn)，共需要调整n-1次。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
数据结构课程设计报告---构件标识系统学院：软件学院专业：软件工程年级 ***姓名：***学号：***一、系统开发平台1.1题目：构件标识1.2开发工具：VC++6.01.3语言：C++1.3操作系统：Windows XP 或Windows7系统二、系统规划2.1任务陈述：图是由非连通图和连通图构成的，非连通图又由几个独立的子连通图构成，每个子连通图称为一个构件，本系统需要将非连通图的子连通图进行标记构件，并图形化演示构件标识的过程。
2.2任务目标：（1）根据所输入数据构造图，形成直观的图形；（2）运用BFS算法将所输入数据构成的图进行标识，演示标识过程，并将不同构件的顶点标识成不同的颜色；（3）输入错误弹出对话框提示；（4）使用多组测试数据证明结果正确。
三、系统定义3.1系统边界：3.2系统描述：本系统是一个实现实际应用性很强的功能的系统。
实际生活中，有很多方面需要对一个大的系统按照其相互关联的关系进行小的分类，这需要建立一个模型，本系统抽象其为无向图的模型，实现对子连通图的标识。
其中通过输入图中顶点数和边数以及开始遍历的顶点进行图的构造，图形显示无向图，并显示图的构件的个数及各不同构件的元素组成。
四、需求分析4.1 数据结构需求：输入为图中各顶点和各边（不用逗号和空格隔开，直接连接输入为一行即可），还需要输入开始进行遍历的顶点；输出为输入数据所构成的无向图（即是根据BFS算法所输出的不同颜色标识的构件图）和构件的个数以及各构件的元素组成。
4.2 操作需求：首先输入顶点数，边数和各个顶点各个边以及开始遍历的顶点，输入完成后点击BFS按钮将所输入的数据生成构件图在下边的图形界面显示，可以点击上一步或下一步按钮浏览生成过程。
4.3 系统需求说明:（1）可供11个顶点以及最多55条边存储的空间；（2）以秒为单位的响应速度；（3）能对数据输入的各种不同序列做出相应的响应。
五、数据结构设计5.1逻辑结构:非线性结构，无向图由顶点和边构成，分为连通图和非连通图，非连通图又由几个小的子连通图构成，进行构件时，分别对图中的子连通图进行标识。
5.2 存储结构:采用邻接多重链表结构存储数据，如下图所示：六、算法设计6.1抽象数据类型ADT AMLGraph(无向图){数据对象: 具有相同特征的无向图中的顶点集和边；typedef struct EBox{VisitIf mark; (访问标记)int ivex,jvex; (该边依附的两个顶点的位置 )struct EBox *ilink,*jlink; (分别指向依附这两个顶点的下一条边 ) }EBox;typedef struct{VertexType data;EBox *firstedge; ( 指向第一条依附该顶点的边 ) }VexBox;typedef struct{VexBox adjmulist[MAX_VERTEX_NUM];(存储顶点及其指针的数组)int vexnum,edgenum; ( 无向图的当前顶点数和边数) }AMLGraph; 基本操作：CreatGragh( CString X ， CString Y) 操作结果：构造无向图；int LocateVex(AMLGraph G,VertexType u)操作结果：寻找顶点在图中的位置；VertexType& GetVex(AMLGraph G,int v) 操作结果：返回v的顶点值int FirstAdjVex(AMLGraph G,VertexType v) 操作结果：寻找v 的第一个邻接顶点；int NextAdjVex(AMLGraph G,VertexType v,VertexType w) 操作结果：返回v 的(相对于w 的)下一个邻接顶点； int MarkUnvisited(AMLGraph &G) 操作结果：标记边为unvisited ；int DeleteVex(AMLGraph &G,VertexType v) 操作结果：删除G 中顶点v 及其相关的边； void DestroyGraph(AMLGraph &G) 操作结果：销毁一个图；}ADT 抽象数据类型名称6.2 算法思想流程图运用邻接多重链表的存储方式，存储图的顶点和边，根据所输入的数据构成所需要的无向图，然后根据BFS 算法，从输入的遍历顶点开始，应用队列和数组实现图的构造；并且在图中的编辑框中显示构件的个数和各构件的组成元素（顶点）。
七、功能模块7.1功能模块1.输入数据，包括图的各顶点，各边以及生成图的开始顶点（根据BFS算法开始遍历的顶点）；2图形显示输入的的数据所构成的图，并用不同的颜色标识子连通图，即图的不同构件；3.显示图的构件的个数和组成各个构件的顶点。
7.2 界面设计八、测试和运行1.输入顶点数据abcdeae，弹出窗口如下：2.输入边为abba，弹出窗口如下：3.不输入数据，弹出提示对话框如下：3.输入俩个遍历顶点是，弹出窗口如下：4.输入顶点：abcde 边为：aa ；开始遍历顶点：a 如下：开始遍历顶点为b时如下：5.输入正确的数据，顶点为abcd，边为abacad，遍历顶点为c窗口如下：开始遍历顶点为a，如下：6.输入顶点为abcdef，边为abacbcdedf 开始遍历的顶点为a如下图形界面：九、总结经过不到俩周的紧张的数据结构的课程设计，我学到了许多东西也深深体会到了做程序员的不易。
从刚开始对课程的迷茫，不知道要怎么做，感觉无从下手到后来慢慢懂得了如何下手，这个过程是艰难的，但结果却是喜悦的，但是事情总是没有我们想的那样简单，问题接踵而来，对于我做的课程设计来说，那便是在界面上显示图形，查了好多资料都没有实例可供参考，最终不得不自己硬着头皮使劲想，才把代码写出来，可问题又来了，运行时出现了错误，在经过了n多遍的检查后才发现错误，改正错误。
可是尽管过程如此艰难，但是当图形显示出来的那一刻，心里的喜悦却是无法言喻的，功夫不负有心人的感觉。
同时我也明白了做好一个系统首先要做好的就是需求分析，包括数据需求和系统需求，这关系着你后来的设计功能是否满足要求以及设计的系统的强大性，这些东西我以前是不怎么会提前考虑的，总是直接下手代码，但是实践证明这个分析必不可少，它可以防止你写程序时，误入错误的方向。
总之，有付出就有回报，你不逼自己一把，永远不知道自己有多优秀！话说回来，系统还有许多不足之处，这就需要以后学习更多的知识来弥补这个缺憾，争取做到最好！附：参考文献Visual C++ 从入门到精通；Visual C++ 实践指导教程。
附：程序清单(部分)typedef enum{unvisited,visited}VisitIf;typedef struct EBox{VisitIf mark; /* 访问标记 */int ivex,jvex; /* 该边依附的两个顶点的位置 */struct EBox *ilink,*jlink; /* 分别指向依附这两个顶点的下一条边 */ }EBox;typedef struct{VertexType data;EBox *firstedge; /* 指向第一条依附该顶点的边 */}VexBox;typedef struct{VexBox adjmulist[MAX_VERTEX_NUM];int vexnum,edgenum; /* 无向图的当前顶点数和边数 */}AMLGraph;AMLGraph CreatGraph( CString vex,CString ege){AMLGraph G;int i,j,k,cur=0; int m=-1;VertexType va,vb;G.vexnum= vex.GetLength();G.edgenum = (ege.GetLength())/2;EBox *p;for(i=0;i<G.vexnum;++i)/* 构造顶点向量 */{G.adjmulist[i].data = vex.GetAt(i);G.adjmulist[i].firstedge = 0;}for(k=0;k<G.edgenum;k++) /* 构造表结点链表 */{va=ege.GetAt(++m);vb=ege.GetAt(++m);i=LocateVex(G,va); /* 一端 */j=LocateVex(G,vb); /* 另一端 */p=(EBox*)malloc(sizeof(EBox));p->mark=unvisited; /* 设初值 */p->ivex=i;p->jvex=j;p->ilink=G.adjmulist[i].firstedge; /* 插在表头 */G.adjmulist[i].firstedge=p;p->jlink=G.adjmulist[j].firstedge; /* 插在表头 */G.adjmulist[j].firstedge=p; /*插入j链表尾部*/}return G;}int Jiucuo( CString vex, CString ege, CString kkd)//判断所输入数据的正确性{int dds = vex.GetLength();int bs = ege.GetLength();int ksdd = kkd.GetLength();char * D = new char[dds];char * B = new char[bs];for(int i = 0; i<dds; i++ )D[i]= vex.GetAt(i);for (int j=0; j< bs; j++)B[j]= ege.GetAt(j);if(dds == 0|| bs ==0 || ksdd ==0){::MessageBox(NULL,_T("请输入数据"),_T("提示"),MB_OK);return ERROR;} if(bs%2 !=0){::MessageBox(NULL,_T("请输入边的个数为偶数"),_T("提示"),MB_OK);return ERROR;}if(ksdd >1){::MessageBox(NULL,_T("请输入一个遍历顶点"),_T("提示"),MB_OK);return ERROR;}for(int m= 0; m<dds; m++){char h = D[m];for(int n= m+1; n<dds; n++)if(D[n]==h) {::MessageBox(NULL,_T("请输入不同的顶点"),_T("提示"),MB_OK);return ERROR;}}for(int mm= 0; mm<bs; mm++){char b = B[mm++];char k = B[mm];for(int jj= mm+1; jj<bs; jj++){char a = B[jj] ;char c = B[++jj];if(a==b&&c==k || a==k&& c==b ) {::MessageBox(NULL,_T("请输入不同的边"),_T("提示"),MB_OK);return ERROR;}}}for (int ii= 0; ii<bs; ii++){int hh = B[ii];int js = 0;for(int xx = 0 ; xx< dds; xx++){if(hh!=D[xx]) js++;}if(js ==dds ){::MessageBox(NULL,_T("输入的边不正确，请输入图中顶点的边"),_T("提示"),MB_OK);return ERROR;}}return OK;}void Shuchu(AMLGraph &G, char s)//其中s 为图的顶点{int v,u,w,z;int m=-1;int mm = 0;LinkQueue Q;int n = G.vexnum;for(v=0;v<G.vexnum;v++)Visited[v]=0;InitQueue(Q);z=LocateVex(G,s);for(v=0;v<G.vexnum;v++){ m++;if(m>=1) {Goujian = Goujian + ";";}if(!Visited[(v+z)%G.vexnum]) /* v尚未访问 */{ mm++;Visited[(v+z)%G.vexnum]=1;/* 设置访问标志为TRUE(已访问) */ Goujian = Goujian + G.adjmulist[(v+z)%G.vexnum].data;EnQueue(Q,(v+z)%G.vexnum);while(!QueueEmpty(Q)) /* 队列不空 */{DeQueue(Q,u);for(w=FirstAdjVex(G,G.adjmulist[u].data);w>=0;w=NextAdjVex(G,G.adjmulist[u].da ta,G.adjmulist[w].data)){if(!Visited[w]){Visited[w]=1;Goujian = Goujian + G.adjmulist[w].data;EnQueue(Q,w);}}}}}itoa(mm,&s,10);Geshu = s;}void BFShuatu(AMLGraph G,VertexType start){ /*从start顶点起,广度优先遍历图G*/int v,u,w,z;int m=-1;int a = -1;int b = -1;LinkQueue Q;int n = G.vexnum;int *X= new int[n];int *Y = new int[n];int *DX = new int[n];//存放的坐标与每个顶点的位置相对应 int *DY = new int[n];for(v=0;v<G.vexnum;v++)Visited[v]=0; /* 置初值 */InitQueue(Q);z=LocateVex(G,start);for(v=0;v<G.vexnum;v++){m++;CPen pen(PS_SOLID,1,RGB(50*m,0,0));SelectObject(hdc,pen);if(!Visited[(v+z)%G.vexnum]) /* v尚未访问 */{Visited[(v+z)%G.vexnum]=1;/* 设置访问标志为TRUE(已访问) */ EnQueue(Q,(v+z)%G.vexnum);x0=660/6+(m*50);y0=340/5;x=x0; y=y0;MoveToEx(hdc,x,y,NULL); //在当前结点和源结点用直线连接LineTo(hdc,x0,y0);X[++a]=x;Y[a]=y;DX[(v+z)%G.vexnum] = x0;DY[(v+z)%G.vexnum] = y0;Rectangle(hdc,x0-1,y0-1,x0+13,y0+19); //画框框TextOut(hdc,x,y, &G.adjmulist[(v+z)%G.vexnum].data,1); //在当前坐标输出T->datawhile(!QueueEmpty(Q)) /* 队列不空 */{DeQueue(Q,u);x0=X[++b];y0=Y[b];int q =0;for(w=FirstAdjVex(G,G.adjmulist[u].data);w>=0;w=NextAdjVex(G,G.adjmulist[u].da ta,G.adjmulist[w].data)){q++;if(!Visited[w]){Visited[w] = 1;EnQueue(Q,w);if(x<=x0) x+=20*q;else x-=20*q;y += 10*q;MoveToEx(hdc,x,y,NULL); //在当前结点和源结点用直线连接 LineTo(hdc,x0,y0);X[++a]=x;Y[a]=y;DX[w]= x;DY[w]= y;Rectangle(hdc,x-1,y-1,x+13,y+19); //画框框VertexType h = G.adjmulist[w].data;TextOut(hdc,x,y, &h,1); //在当前坐标输出T->data}if(Visited[w]){int xz = DX[w];int yz = DY[w];MoveToEx(hdc,xz,yz,NULL);LineTo(hdc,x0,y0);}}}}}DestroyQueue(Q);/*销毁队列,释放其占用空间*/ }。