数据结构

typedef struct _ast ast;typedef struct _ast *past;struct _ast{ int ivalue; char* nodeType; past left; past right;}; //结构的定义past newAstNode() //创建新的节点{ past node = malloc(sizeof(ast)); //分配节点空间 if(node == NULL) { printf("run out of memory. "); exit(0); } memset(node, 0, sizeof(ast)); return node;}past newNum(int value) //为节点赋值{ past var = newAstNode(); var->nodeType = "intValue"; var->ivalue = value; return var; }past newExpr(int oper, past left,past right) //为新建节点赋值的函数{ past var = newAstNode();//-----------------------为节点结构成员赋值var->nodeType = "expr"; var->ivalue = oper; var->left = left; var->right = right; return var;}你参考下吧。

地大的？？

多学学硬件知识。汇编要好好复习哦。

第1章绪论11.1数据与数据结构21.1.1数据及其类型21.1.2数据结构简介41.2算法61.2.1算法的概念61.2.2算法的分析81.2.3算法的设计121.3C++语言简介181.3.1C++的产生与发展181.3.2C++与面向对象思想201.3.3C++中的类和对象231.4本章小结28第2章C++编程基础292.1开始C++编程302.1.1输入输出302.1.2预处理382.1.3名字空间442.2深入的类编程502.2.1访问控制502.2.2初始化与清除532.2.3动态创建对象572.2.4友元函数602.2.5拷贝构造函数612.3丰富的C++特性652.3.1常量652.3.2函数重载682.3.3运算符重载712.3.4异常处理772.4代码重用机制792.4.1继承802.4.2多态872.4.3模板902.5标准模板库932.5.1STL简介942.5.2STL构成952.5.3STL的不同版本972.6本章小结98第3章指针、数组与字符串993.1指针1003.1.1指针的概念1003.1.2指针的语法1023.1.3函数与参数传递1033.2数组1083.2.1数组定义与初始化1093.2.2数组与指针1133.2.3数组的抽象数据类型1163.2.4大整数乘法问题1203.2.5荷兰国旗问题1213.3字符串1243.3.1C++中的字符串1243.3.2字符串抽象数据类型1263.3.3字符串的匹配算法1283.3.4字符串指数问题1413.4动态内存管理1423.4.1关键词new和delete1433.4.2避免内存错误1463.5本章小结152第4章链表1534.1单向链表1544.1.1单向链表的结构1544.1.2单向链表类的实现1554.1.3有序链表的合并1624.1.4多项式加法问题1634.2单向循环链表1644.2.1单向循环链表的结构1644.2.2单向循环链表类的实现1664.2.3约瑟夫问题1694.2.4魔术师发牌问题1704.2.5拉丁方阵问题1724.3双向循环链表1734.3.1双向循环链表的结构1734.3.2双向循环链表类的实现1744.3.3Vigenere加密问题1824.3.4选美比赛问题1844.4游标类的设计与实现1864.4.1游标类的结构1864.4.2游标类的实现1874.5STL与链表1914.5.1STL中链表类的接口1914.5.2遍历1944.5.3元素的插入与删除1964.6本章小结196第5章栈与队列1975.1栈1985.1.1栈的结构1985.1.2栈的实现1995.1.3括号匹配问题2035.1.4停车场模拟问题2045.2队列2085.2.1队列的结构2085.2.2队列的实现2105.2.3舞伴问题2145.2.4杨辉三角形问题2155.2.5游程编码问题2165.3优先级队列2185.3.1优先级队列的结构2185.3.2优先级队列的实现2205.4STL中的栈与队列2225.4.1STL中的stack2225.4.2STL中的queue2245.4.3STL中的priority_queue2265.5本章小结229第6章递归2316.1递归的概念2326.1.1递归的定义2326.1.2应用递归的原则2356.1.3递归和非递归的转化2406.2分治法2436.2.1分治法简述2436.2.2汉诺塔问题2446.2.3传染病问题2466.3回溯法2506.3.1回溯法简述2516.3.2迷宫问题2516.3.3八皇后问题2556.3.4骑士周游问题2586.4本章小结265第7章树2677.1树的概念2687.1.1树的定义2687.1.2树的术语2717.1.3树的抽象数据类型2727.2二叉树2737.2.1二叉树的定义2737.2.2二叉树的性质2757.2.3二叉树的实现2767.2.4二叉树的遍历2857.2.5二叉树的线索化2897.3树与森林2917.3.1树的存储表示2917.3.2树的实现2947.3.3树与森林的遍历2987.3.4森林与二叉树的转换3007.4霍夫曼树3047.4.1霍夫曼树的概念3047.4.2霍夫曼树的构造方法3057.4.3霍夫曼编码及其实现3077.5堆3137.5.1堆的概念3147.5.2堆的建立3147.5.3堆的操作3167.6基于STL实现树结构3177.6.1STL中的vector3177.6.2STL中的map3217.7医院建模问题3237.8本章小结328第8章图3298.1图的基本概念3308.1.1图的定义3308.1.2图的术语3318.1.3图的运算3348.1.4图的抽象数据类型3368.2图的存储与表示3378.2.1图的邻接矩阵表示3378.2.2图的邻接表表示3398.2.3两种表示法的比较3428.3图的遍历3428.3.1欧拉路径与欧拉回路3438.3.2哈密尔顿路径与哈密尔顿回路3458.3.3广度优先遍历3468.3.4深度优先遍历3498.4最短路径问题3538.4.1固定起点最短路问题3538.4.2非固定起点最短路问题3558.4.3最短路径的动态规划解法3588.4.4旅游交通路线问题3648.5最小生成树3728.5.1最小生成树的定义3728.5.2克鲁斯卡尔算法3738.5.3普里姆算法3758.6经典问题举例3798.6.1文字游戏问题3808.6.2道路修建问题3828.6.3回家路线问题3858.6.4水塘计算问题3878.6.5棍子还原问题3898.7本章小结392第9章树形搜索结构3939.1二叉搜索树3949.1.1二叉搜索树的概念3949.1.2二叉搜索树的操作3959.1.3二叉搜索树的实现3979.1.4二叉搜索树的分析4009.2AVL树4039.2.1AVL树的概念4049.2.2AVL树的旋转4059.2.3AVL树的实现4109.3红黑树4189.3.1红黑树的概念4189.3.2红黑树的操作4219.3.3红黑树的实现4289.4Trie树4339.4.1Trie树的概念4339.4.2Trie树的表示4349.4.3Trie树的实现4359.5本章小结439第10章集合与字典44110.1集合论基础44210.1.1集合的概念44210.1.2集合的运算44410.2集合的实现44510.2.1位向量集合44510.2.2链表集合45110.3字典46010.3.1字典的概念46110.3.2搜索运算46310.4散列46710.4.1散列的概念46710.4.2散列函数46910.4.3处理散列冲突47110.4.4散列的应用47510.5经典问题举例47610.5.1拼写检查问题47610.5.2无线网络问题48510.5.3第K个数问题48810.6STL中的set49010.7本章小结493第11章排序49511.1排序问题概述49611.1.1基本概念和定义49611.1.2排序算法的分类49711.1.3排序算法分析与选择49711.2插入排序49811.2.1直接插入排序49811.2.2二分法插入排序50111.2.3希尔排序50311.3选择排序50611.3.1直接选择排序50611.3.2堆排序50811.4交换排序51211.4.1冒泡法排序51211.4.2Shaker排序51411.4.3快速排序51711.5归并排序52211.6计数排序52611.7本章小结531参考文献533……

不靠。计算机考研408数据结构考试内容是计算机组成原理、操作系统等，红黑树是一种特殊形式的平衡二叉搜索树，根据查询相关资料，2022年08考纲的修订，平衡树、红黑树、外部排序等都不被列入考核中，所以不会考红黑树。

1、MySQL支持的索引结构有四种：B+树，R树，HASH，FULLTEXT。B树是一种多叉的AVL树。B-Tree减少了AVL数的高度，增加了每个节点的KEY数量。2、其余节点用来索引，而B-树是每个索引节点都会有Data域。这就决定了B+树更适合用来存储外部数据，也就是所谓的磁盘数据。3、mysql的数据结构用的是b+而不是b红黑树等数据结构也可以用来实现索引，但是文件系统及数据库系统普遍采用B-/+Tree作为索引结构，这一节将结合计算机组成原理相关知识讨论B-/+Tree作为索引的理论基础。

1. 数据结构的定义。 2. 栈的两个应用：括号匹配和表达式的计算。是怎么应用的？表达式计算用的是哪种表达方式？有什么好处? 3. 字符串匹配算法：朴素的匹配算法、KMP算法。 4. 二叉树前序、中序、后序递归遍历算法。二叉树前序非递归遍历算法。 5. 堆，建堆算法，堆的插入和删除算法，堆排序。 6. 哈希。哈希函数的有哪些种？余数的取法？ 处理冲突的方法？ 闭散列方法有哪些？ 7. 二叉搜索树的搜索、插入、删除。时间复杂度。 8. 二叉平衡树的插入结点的原理，有哪几种旋转方式？分别适用于哪种情况。分析二叉平衡树的时间复杂度。 9. 红黑树的定义，红黑树的性能分析和与二叉平衡树的比较。 10. 图有哪些储存表示。 11. 链表插入排序、链表归并排序。 12. 常见的有哪几种排序算法，试比较其时间复杂度，以及是否稳定，及各自使用的情形。 13. 常用分配排序有哪几种？ 基数排序的定义，分类及原理。 14. 外部排序的过程。 15. B树、B+树、Trie的概念及用途，添加删除结点的原理。

考研408要考四门课，数据结构，操作系统，计算机组成原理及计算机网络，相对自主数据结构，要难一些，自主命题数据结构可以复习班，或一相关材料，这样容易获得高分吧。这个也相对的，要看报告的高校。

关于C++的 我也是没好好学啊,..

需要时间

有向图的极大强连通子图，称为强连通分量（strongly connected components）。

问题很深奥 - -!

学数据结构就是让你搞懂计算机处理非数字问题时的数据的逻辑结构和存储结构的。所以，原理很重要 一定要把能实现那些数据的逻辑结构和存储结构记清楚。在以后处理问题的时候，看实际问题能用学到的哪个数据结构去解决数据的存储。

【 #考研# 导语】厦门理工学院（Xiamen University of Technology）是经教育部批准成立的全日制普通本科高等学校，入选福建省一流学科建设高校、福建省闽台高校联合培养人才项目试点高校、卓越工程师教育培养计划、福建省重点建设高校、“十三五”应用型本科产教融合发展工程、中国政府奖学金委托培养院校、全国首批深化创新创业教育改革示范高校、全国深化创新创业教育改革特色典型经验高校等。 【厦门理工学院2019年941电路分析研究生考试初试大纲】 一、考试科目代码和名称： 　　941电路分析 　　二、招生院系和专业： 　　光电与通信工程学院 光学工程方向 　　考试要求： 　　1、本考试大纲适用于厦门理工学院光学工程领域专业学位硕士研究生的入学考试。 　　2、课程考试旨在考查学生对有关电路方面的基础理论、基本概念、基本知识和解决基本、实际问题的能力。 　　考试方式： 　　笔试、闭卷(考生可自带计算器和绘图工具)。 　　考试内容比例：(卷面成绩150分) 　　1、填空(40分) 　　2. 简单分析计算(70分) 　　3、综合分析计算(2х20=40分) 　　基本内容及范围: 　　1、电路的基本概念与基本电路定律 　　2、电阻电路的一般分析：电路等效分析，网孔电流法，节点电压法 　　3、常用电路定理：叠加与齐次性定理;等效电源定理;功率传输定理。 　　4、一阶动态电路的三要素分析：动态电路中初始值的确定 　　5、正弦稳态电路分析：等效阻抗，功率因数，有功功率，无功功率等。 　　6、电路的频率响应：网络函数的求解。 　　参考教材： 　　邱关源 著 《电路》(第5版) 高等教育出版社 【厦门理工学院2019年922数据结构研究生考试初试大纲】 一、考试科目名称： 　　数据结构 　　二、招生系部和专业： 　　电气工程与自动化学院 电气工程方向 　　考试要求： 　　要求考生能比较全面的理解与掌握数据结构的基本概念、基本原理和基本方法，掌握数据的逻辑结构、存储结构及基本操作的实现，能够对算法进行基本的时间复杂度及空间复杂度的分析;能够根据数据结构基本原理和方法进行问题的分析与求解，具备采用C或C++语言设计与实现算法的能力。 　　考试题型及比例： 　　分析运算题+算法设计(100%) 　　基本内容及范围： 　　第一章 引论 　　一、考核知识点 　　数据结构,数据类型,抽象数据类型基本概念;算法分析基本概念;算法复杂度基本概念;常见基本算法的时间复杂度分析;时间复杂度的几种表示法; 　　二、考核要求 　　1、了解数据、数据结构、抽象数据类型以及算法等概念的确切含义; 　　2、熟悉数据逻辑结构、存贮结构等概念; 　　3、掌握算法复杂度分析的基本概念及分析方法; 　　第二章 线性表 　　一、考核知识点 　　线性表的逻辑结构定义、基本操作和在两种存储结构中基本操作的实现;链表;用线性表表示一元多项式及实现稀疏多项式的相加等运算。 　　二、考核要求 　　1、了解线性表的概念 　　2、掌握顺序表上各种运算的实现方法 　　3、掌握各种链表的存储结构及运算。 　　第三章 栈和队列 　　一、考核知识点 　　栈和队列的结构特性、基本操作及在两种存储结构上基本操作的实现;栈和队列的应用、递归算法的设计。 　　二、考核要求 　　1、了解栈与队列的概念 　　2、掌握顺序栈、顺序队列，链栈、队列的各种运算的实现方法 　　3、掌握栈与递归的概念。 　　第四章 串 　　一、考核知识点 　　串的逻辑结构定义、串的基本运算及其实现;串的匹配算法。 　　二、考核要求 　　1、了解串的概念 　　2、掌握串的存贮和基本运算方法。 　　第五章 数组和广义表 　　一、考核知识点 　　数组的逻辑结构定义和存储方法;特殊矩阵和稀疏矩阵的压缩存储方法;广义表的逻辑结构和存储结构以及广义表运算的递归算法。 　　二、考核要求 　　1、了解数组的逻辑结构定义和存储方法 　　第六章 树和二叉树 　　一、考核知识点 　　树的基本概念;二叉树的定义、性质、存储表示;二叉树的遍历;线索二叉树;森林和二叉树的相互转换;树的应用;哈夫曼树及哈夫曼编码。 　　二、考核要求 　　1、了解树和二叉树的概念 　　2、掌握树与二叉树的转换 　　3、掌握树、森林、二叉树遍历的方法及二叉树遍历的实现算法，线索化二叉树及其运算，哈夫曼树及哈夫曼编码等概念。 　　第七章 图 　　一、考核知识点 　　图的基本概念、存储表示(邻接矩阵、邻接表、十字链表，邻接多重表);图的遍历、图的连通性问题;拓扑排序、关键路径;最短路径。 　　二、考核要求 　　1、了解图的概念 　　2、掌握图的存贮表示法，图的遍历及算法，生成树和最小生成树的概念 　　3、掌握最短路径，拓扑排序和关键路径等图的应用方法。 　　第九章 查找 　　一、考核知识点 　　查找表是集合类型的数据结构，其操作借助静态查找表、动态查找表、哈希表实现; 　　二、考核要求 　　1、掌握查找的概念 　　2、掌握线性表的查找(顺序查找，二分法查找，分块查找)，树表的查找(二叉排序树、平衡二叉树)，散列表的查找及相应处理算法。 　　第十章 排序 　　一、考核知识点 　　内部排序介绍插入排序、快速排序(交换排序)、选择排序、归并排序;排序的基本思想和算法分析。 　　外部排序介绍外存储器(磁带、磁盘)简介;多路平衡归并、置换选择排序、归并树及磁带归并排序。 　　参考教材： 　　1、严蔚敏等 著《数据结构(C语言版)》清华大学出版社 　　说明： 　　1、考试基本内容：一般包括基础理论、实际知识、综合分析和论证等几个方面的内容。 　　2、难易程度：根据大学本科的教学大纲和本学科、专业的基本要求，一般应使大学本科毕业生中优秀学生在规定的三个小时内答完全部考题，略有一些时间进行检查和思考。排序从易到难。

Answer:D A A C B C C......Ps:哪题有疑问可以追问我....

C++ Queues 队列：先进先出back() 返回最后一个元素 empty() 如果队列空则返回真 front() 返回第一个元素 pop() 删除第一个元素 push() 在末尾加入一个元素 size() 返回队列中元素的个数

搜索引擎的核心数据结构为倒排文件（也称倒排索引），倒排索引是指用记录的非主属性值(也叫副键)来查找记录而组织的文件叫倒排文件，即次索引。倒排文件中包括了所有副键值，并列出了与之有关的所有记录主键值，主要用于复杂查询。 与传统的SQL查询不同，在搜索引擎收集完数据的预处理阶段，搜索引擎往往需要一种高效的数据结构来对外提供检索服务。而现行最有效的数据结构就是“倒排文件”。倒排文件简单一点可以定义为“用文档的关键词作为索引，文档作为索引目标的一种结构（类似于普通书籍中，索引是关键词，书的页面是索引目标）。

结合电脑一起，效果最好吧。

#include<iostream>#include<stdlib.h>#include<windows.h>#include<string>#include<conio.h>#define FILE_PATH "D:/text.txt"using namespace std;int superscript[20];int MARK=0;char FLAG="f";int credits=0;struct Node{ char data[10]; int num; Node *next;};class Stack {public: Stack(){top=NULL;} ~Stack(){} void Push(char a[10],int num); void Pop(FILE *fp,int cre); int Empty() { if(top==NULL) return 0; else return 1; }private: Node *top;};void Stack::Push(char a[],int num){ Node *m; m=new Node; strcpy(m->data,a); m->num=num; m->next=top; top=m;}void Stack::Pop(FILE *fp,int cre){ char a[10]; int num; Node *p; if(top==NULL) { cout<<" "; } else { credits+=top->num; if(credits<=cre) { strcpy(a,top->data); num=top->num; p=top; top=top->next; delete p; cout<<a<<" "<<num<<" "; fprintf(fp,"%s %d ",a,num); MARK=0; } else if(credits>cre) { MARK=1; credits-=top->num; } }}struct ArcNode{ int adjvex; ArcNode *next;};struct VertexNode{ int in; char CourseNum[10]; char ProCourseNum[10][10]; int Credit; ArcNode *firstedge;};class Courses{public: Courses(int n); ~Courses(){}; void Plan1(Courses a,int term,int cre); void Plan2(Courses a,int term,int cre);private: VertexNode adjlist[20]; int vertexNum;};Courses::Courses(int n){ int i,j,k; ArcNode *s; vertexNum=n; for(i=0;i<vertexNum;i++) { k=0; cin>>adjlist[i].CourseNum; cin>>adjlist[i].Credit; while(1) { cin>>adjlist[i].ProCourseNum[k]; if(strcmp(adjlist[i].ProCourseNum[k],&FLAG)==0) break; k++; } adjlist[i].firstedge=NULL; adjlist[i].in=0; } for(i=0;i<vertexNum;i++) for(j=0;j<vertexNum;j++) { k=0; while(1) { if(strcmp(adjlist[j].ProCourseNum[k],&FLAG)==0) break; else if(strcmp(adjlist[j].ProCourseNum[k],adjlist[i].CourseNum)==0) { s=new ArcNode; s->adjvex=j; s->next=adjlist[i].firstedge; adjlist[i].firstedge=s; adjlist[j].in++; } k++; } }};void Courses::Plan1(Courses co,int term,int cre){ ArcNode *p; FILE *fp=NULL; int a[10]; int j=0,f=0,k,i,l=0,m=0,z,count=0,addterm=0,flag=0; Stack s; for(i=0;i<co.vertexNum;i++) { if(co.adjlist[i].in==0) { s.Push(co.adjlist[i].CourseNum,co.adjlist[i].Credit); superscript[j]=i; j++; } } fp=fopen(FILE_PATH,"w"); if(fp!=NULL) { fprintf(fp," 教学计划安排如下 "); while(s.Empty()==1) { if(flag==1) break; l=0;j=0; while(s.Empty()==1) { addterm++; if(addterm>term) { cout<<"课程条件与学期条件不符,出现错误,抱歉!!"<<endl; fprintf(fp,"课程条件与学期条件不符,出现错误,抱歉!!"); flag=1; break; } credits=0; cout<<"第"<<addterm<<"学期应安排的课程为:"; fprintf(fp,"第%d学期应安排的课程为:",addterm); for(z=0;z<2;z++) { s.Pop(fp,cre); a[l]=superscript[j]; j++; l++; if(MARK==1) break; count++; } cout<<"本学期获得学分为:"<<credits<<"分"; fprintf(fp,"本学期获得学分为:%d分",credits); cout<<endl; fprintf(fp," "); } j=0; for(f=0;f<l;f++) { m=a[f]; p=co.adjlist[m].firstedge; while(p!=NULL) { k=p->adjvex; co.adjlist[k].in--; if(co.adjlist[k].in==0) { s.Push(co.adjlist[k].CourseNum,co.adjlist[k].Credit); superscript[j]=k; j++; } p=p->next; } } } } while(addterm<term) { addterm++; cout<<"第"<<addterm<<"学期无课程安排"<<endl; fprintf(fp,"第%d学期无课程安排 ",addterm); } fclose(fp); if(count<co.vertexNum) cout<<"课程安排出错!"<<endl;}void Courses::Plan2(Courses co,int term,int cre){ ArcNode *p; FILE *fp=NULL; int a[10]; int j=0,f,i,k,l=0,m=0,count=0,addterm=0,flag=0,zhan=0; Stack s; for(i=0;i<co.vertexNum;i++) { if(co.adjlist[i].in==0) { s.Push(co.adjlist[i].CourseNum,co.adjlist[i].Credit); superscript[j]=i; j++; } } fp=fopen(FILE_PATH,"w"); if(fp!=NULL) { fprintf(fp," 教学计划安排如下 "); while(s.Empty()==1) { l=0;j=0; addterm++; if(addterm>term) { cout<<"课程条件与学期条件不符,出现错误,抱歉!!"<<endl; fprintf(fp,"课程条件与学期条件不符,出现错误,抱歉!!"); break; } credits=0; cout<<"第"<<addterm<<"学期应安排的课程为:"; fprintf(fp,"第%d学期应安排的课程为:",addterm); while(s.Empty()==1) { s.Pop(fp,cre); a[l]=superscript[j]; j++; l++; if(MARK==1) break; count++; } cout<<"本学期获得学分为:"<<credits<<"分"; fprintf(fp,"本学期获得学分为:%d分",credits); cout<<endl; fprintf(fp," "); j=0; for(f=0;f<l;f++) { m=a[f]; p=co.adjlist[m].firstedge; while(p!=NULL) { k=p->adjvex; co.adjlist[k].in--; if(co.adjlist[k].in==0) { s.Push(co.adjlist[k].CourseNum,co.adjlist[k].Credit); superscript[j]=k; j++; } p=p->next; } } } } while(addterm<term) { addterm++; cout<<"第"<<addterm<<"学期无课程安排"<<endl; fprintf(fp,"第%d学期无课程安排 ",addterm); } fclose(fp); if(count<co.vertexNum) cout<<"课程安排出错!"<<endl;}void show(){ cout<<endl; cout<<"$**************************************************************************$"<<endl; cout<<"$ 科目 学分 科目 学分 科目 学分 $"<<endl; cout<<"$ 01.C语言-------------2 02.高等数学--------2 03.离散数学-------1 $"<<endl; cout<<"$ 04.数字逻辑----------2 05.计算机组成原理--1 06.面向对象程序---3 $"<<endl; cout<<"$ 07.数据结构与算法----3 08.数据库原理------4 09.Java语言-------4 $"<<endl; cout<<"$ 10.图形程序设计------3 11.嵌入式操作系统--2 12.大型数据库技术-3 $"<<endl; cout<<"$**************************************************************************$"<<endl;}int main(){ int i,max,m,k=1,term; string FIRST="1"; string SECOND="2"; system("color 75"); char ch; string g; for(i=0;i<6;i++) cout<<endl; cout<<" $**************************************************$"<<endl; cout<<" $ $"<<endl; cout<<" $ 欢迎进入教学计划编制系统!!! $"<<endl; cout<<" $ Ver3.14.1.0 $"<<endl; cout<<" $ 郝智博 $"<<endl; cout<<" $ $"<<endl; cout<<" $**************************************************$"<<endl; for(i=0;i<5;i++) cout<<endl; cout<<"请按任意键继续......."; ch=getch(); system("cls"); cout<<"请输入学期总数(请小于等于8个学期)、每学期学分上限(至少为4)以及所需学习课程总数(课程数请小于等于12门):"<<endl; cin>>term>>max>>m; cout<<"请输入每一门课程的课程号、学分、和直接先修课程的课程号(若没有先修课则输入"00",先修课输入完毕按"f"结束):"<<endl; show(); Courses cou(m); system("cls"); cout<<"请选择您所需的安排策略:"<<endl<<"->1.各学期学习负担均匀"<<endl<<"->2.课程集中在前几个学期"<<endl; while(k) { cin>>g; if(g==FIRST) { system("cls"); cout<<"教学安排如下:"<<endl; cou.Plan1(cou,term,max); k=0; } else if(g==SECOND) { system("cls"); cout<<"教学安排如下:"<<endl; cou.Plan2(cou,term,max); k=0; } else { cout<<"输入错误请重新输入"<<endl; k=1; } } cout<<"请按任意键退出......."; ch=getch(); system("cls"); cout<<"教学计划已存入指定文件，感谢您的使用，再见!!"<<endl; return 0;}这个代码基本满足要求了

网上那些dba面试题只能参考，不可过度依赖我先问你一个问题：你是应届生吗？如果是，那么你说的问题都会考如果你有2-3年经验，那么肯定不会考，取而代之的是问你一些以前在你工作过程中的遇到的问题或者项目或者操作等等有什么其他问题可以追问我

不要用1800,用 数据结构习题与解析 B级的 清华大学李春葆出的,这本书每一个题基本都有详细的答案,1800没有,干接触数据集建议用上面那本

现在考408联考的学校还是挺多的，四门课都准备的话确实很难，计算机组成原理没有数据结构简单，个人感觉，考数据结构和程序设计的学校越来越多了。

你比我强

研究密码变化的客观规律，应用于编制密码以保守通信秘密的，称为编码学；应用于破译密码以获取通信情报的，称为破译学，密码学是研究编制密码和破译密码的技术科学。 密码是通信双方按约定的法则进行信息特殊变换的一种重要保密手段。密码学是在编码与破译的斗争实践中逐步发展起来的，并随着先进科学技术的应用，已成为一门综合性的尖端技术科学。它与语言学、数学、电子学、声学、信息论、计算机科学等有着广泛而密切的联系。在西欧语文中之源於希腊语kryptós，“隐藏的”，和gráphein，“书写”）是研究如何隐密的传递信息的学科。在现代特别指对信息以及其传输的数学性研究，常被认为是数学和计算机科学的分支，和信息论也密切相关。著名的密码学者Ron Rivest解释道：「密码学是关於如何在敌人存在的环境中通讯」，自工程学的角度，这相当于密码学与纯数学的异同。密码学是 信息安全等相关议题，如认证、访问控制的核心。密码学的首要目是隐藏信息的涵义，并不是将隐藏信息的存在。密码学也促进了计算机科学，特别是在於电脑与网路安全所使用的技术，如访问控制与信息的机密性。密码学已被应用在日常生活：包括自动柜员机的芯片卡、电脑使用者存取密码、电子商务等等。非对称加密算法的核心就是加密密钥不等于解密密钥，且无法从任意一个密钥推导出另一个密钥，这样就大大加强了信息保护的力度，而且基于密钥对的原理很容易的实现数字签名和电子信封。 比较典型的非对称加密算法是RSA算法，它的数学原理是大素数的分解，密钥是成对出现的，一个为公钥，一个是私钥。公钥是公开的，可以用私钥去解公钥加密过的信息，也可以用公钥去解私钥加密过的信息。 比如A向B发送信息，由于B的公钥是公开的，那么A用B的公钥对信息进行加密，发送出去，因为只有B有对应的私钥，所以信息只能为B所读取。 牢固的RSA算法需要其密钥长度为1024位，加解密的速度比较慢是它的弱点。 另外一种比较典型的非对称加密算法是ECC算法，基于的数学原理是椭圆曲线离散对数系统，这种算法的标准我国尚未确定，但是其只需要192 bit 就可以实现牢固的加密。所以，应该是优于RSA算法的。对于加密，基本上不存在一个完全不可以被破解的加密算法，因为只要你有足够的时间，完全可以用穷举法来进行试探，如果说一个加密算法是牢固的，一般就是指在现有的计算条件下，需要花费相当长的时间才能够穷举成功（比如100年）RSA加密演算法是一种非对称加密演算法。在公钥加密标准和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。1973年，在英国政府通讯总部工作的数学家克利福德·柯克斯（Clifford Cocks）在一个内部文件中提出了一个相应的算法，但他的发现被列入机密，一直到1997年未被发表。RSA算法的可靠性基于分解极大的整数是很困难的。假如有人找到一种很快的分解因子的算法的话，那么用RSA加密的信息的可靠性就肯定会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA钥匙才可能被强力方式解破。到2004年为止，世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。 -------------------------------------------------------------------------RSA加密算法该算法于1977年由美国麻省理工学院MIT(Massachusetts Institute of Technology)的Ronal Rivest，Adi Shamir和Len Adleman三位年轻教授提出，并以三人的姓氏Rivest，Shamir和Adlernan命名为RSA算法。该算法利用了数论领域的一个事实，那就是虽然把两个大质数相乘生成一个合数是件十分容易的事情，但要把一个合数分解为两个质数却十分困难。合数分解问题目前仍然是数学领域尚未解决的一大难题，至今没有任何高效的分解方法。与Diffie-Hellman算法相比，RSA算法具有明显的优越性，因为它无须收发双方同时参与加密过程，且非常适合于电子函件系统的加密。RSA算法可以表述如下：(1) 密钥配制。假设m是想要传送的报文，现任选两个很大的质数p与q，使得：(12-1)；选择正整数e，使得e与(p－1)(q－1)互质；这里(p－1)(q－1)表示二者相乘。再利用辗转相除法，求得d，使得：(12-2)；其中x mod y是整数求余运算，其结果是x整除以y后剩余的余数，如5 mod 3 = 2。这样得：(e，n)，是用于加密的公共密钥，可以公开出去；以及(d，n)，是用于解密的专用钥匙，必须保密。(2) 加密过程。使用(e，n)对明文m进行加密，算法为：(12-3)；这里的c即是m加密后的密文。(3) 解密过程。使用(d，n)对密文c进行解密，算法为：(12-4)；求得的m即为对应于密文c的明文。RSA算法实现起来十分简捷，据说英国的一位程序员只用了3行Perl程序便实现了加密和解密运算。RSA算法建立在正整数求余运算基础之上，同时还保持了指数运算的性质，这一点我们不难证明。例如：(12-5)；(12-6)。RSA公共密钥加密算法的核心是欧拉(Euler)函数ψ。对于正整数n，ψ(n)定义为小于n且与n互质的正整数的个数。例如ψ(6) = 2，这是因为小于6且与6互质的数有1和5共两个数；再如ψ(7) = 6，这是因为互质数有1，2，3，5，6共6个。欧拉在公元前300多年就发现了ψ函数的一个十分有趣的性质，那就是对于任意小于n且与n互质的正整数m，总有mψ(n) mod n = 1。例如，5ψ(6) mod 6 = 52 mod 6= 25 mod 6 =1。也就是说，在对n求余的运算下，ψ(n)指数具有周期性。当n很小时，计算ψ(n)并不难，使用穷举法即可求出；但当n很大时，计算ψ(n)就十分困难了，其运算量与判断n是否为质数的情况相当。不过在特殊情况下，利用ψ函数的两个性质，可以极大地减少运算量。性质1：如果p是质数，则ψ(p) = (p－1)。性质2：如果p与q均为质数，则ψ(p·q) = ψ(p)·ψ(q) = (p－1)(q－1)。RSA算法正是注意到这两条性质来设计公共密钥加密系统的，p与q的乘积n可以作为公共密钥公布出来，而n的因子p和q则包含在专用密钥中，可以用来解密。如果解密需要用到ψ(n)，收信方由于知道因子p和q，可以方便地算出ψ(n) = (p－1)(q－1)。如果窃听者窃得了n，但由于不知道它的因子p与q，则很难求出ψ(n)。这时，窃听者要么强行算出ψ(n)，要么对n进行因数分解求得p与q。然而，我们知道，在大数范围内作合数分解是十分困难的，因此窃密者很难成功。有了关于ψ函数的认识，我们再来分析RSA算法的工作原理：(1) 密钥配制。设m是要加密的信息，任选两个大质数p与q，使得 ；选择正整数e，使得e与ψ(n) = (p－1)(q－1)互质。利用辗转相除法，计算d，使得ed mod ψ(n) = ，即ed = kψ(n) +1，其中k为某一正整数。公共密钥为(e，n)，其中没有包含任何有关n的因子p和q的信息。专用密钥为(d，n)，其中d隐含有因子p和q的信息。(2) 加密过程。使用公式(12-3)对明文m进行加密，得密文c。(3) 解密过程。使用(d，n)对密文c进行解密，计算过程为：cd mod n = (me mod n)d mod n= med mod n = m(kψ(n) + 1) mod n= (mkψ(n) mod n)·(m mod n)= mm即为从密文c中恢复出来的明文。例如，假设我们需要加密的明文代码信息为m = 14，则：选择e = 3，p = 5，q = 11；计算出n = p·q = 55，(p－1)(q－1) = 40，d = 27；可以验证：(e·d) mod (p－1)(q－1) = 81 mod 40 = 1；加密：c = me mod n = 143 mod 55 = 49；解密：m = cd mod n = 4927 mod 55 = 14。关于RSA算法，还有几点需要进一步说明：(1) 之所以要求e与(p－1)(q－1)互质，是为了保证 ed mod (p－1)(q－1)有解。(2) 实际操作时，通常先选定e，再找出并确定质数p和q，使得计算出d后它们能满足公式(12-3)。常用的e有3和65537，这两个数都是费马序列中的数。费马序列是以17世纪法国数学家费马命名的序列。(3) 破密者主要通过将n分解成p·q的办法来解密，不过目前还没有办法证明这是唯一的办法，也可能有更有效的方法，因为因数分解问题毕竟是一个不断发展的领域，自从RSA算法发明以来，人们已经发现了不少有效的因数分解方法，在一定程度上降低了破译RSA算法的难度，但至今还没有出现动摇RSA算法根基的方法。(4) 在RSA算法中，n的长度是控制该算法可靠性的重要因素。目前129位、甚至155位的RSA加密勉强可解，但目前大多数加密程序均采用231、308甚至616位的RSA算法，因此RSA加密还是相当安全的。据专家测算，攻破512位密钥RSA算法大约需要8个月时间；而一个768位密钥RSA算法在2004年之前无法攻破。现在，在技术上还无法预测攻破具有2048位密钥的RSA加密算法需要多少时间。美国Lotus公司悬赏1亿美元，奖励能破译其Domino产品中1024位密钥的RSA算法的人。从这个意义上说，遵照SET协议开发的电子商务系统是绝对安全的。

去课后答案网，或者豆丁网吧，什么答案都有。

git 的对象有两种： 一种是 松散对象 ，就是在如上 .git/objects 的文件夹 03 28 7f ce d0 d5 e6 f9 等，这些文件夹只有 2 个字符开头，其实就是每个文件 SHA-1 值的前 2 个字母，最多有 #OXFF 256 个文件夹。 一种是 打包压缩对象 ，打包压缩之后的对象主要存在的是 pack 文件中，主要用于文件在网络上传输，减少网络消耗。 为了节省存储空间，可以手动触发打包压缩操作 (git gc)，将松散对象打包成 pack 文件对象。也可以将 pack 文件解压缩成松散对象 (git unpack-objects) pack 文件设计非常精密和巧妙，本着降低文件大小，减少文件传输，降低网络开销和安全传输的原则设计的。pack 文件设计的概图如下： pack 文件主要有三部分组成，Header， Body， Trailer 下面我们看具体的 pack 文件： 从上图可知：通过 idx 索引文件在 pack 文件中定位到对象之后，对象的结构主要 Header 和 Data 两部分。 1、Header 部分 Header 中首 8-bits：1-bit 是 MSB，接着的 3-bits 表示的是当前对象类型，主要有6种存储类型，接着的 4-bits 是用于表示该 Object 展开的 (length) 大小的一部分，只是一部分，完整的大小取决于MSB和接下来的多个 bits，完整算法如下： 2 Data 部分 经过 Zlib 压缩过的数据。可能是全部数据，也有可能是 Delta 数据，具体看 Header 部分的存储类型，如果是 OBJ_OFS_DELTA 或者 OBJ_REF_DELTA 此处存储的就是增量 (Delta) 数据，此时如果要取得全量数据的话，需要递归的找到最 Base Object，然后 apply delta 数据，在 base object 基础上进行 apply delta 数据也是非常精妙的，此文暂不做介绍。 从上面可以很清晰知道 pack 文件格式，我们再从本地仓库中一探究竟：不是增量 delta 格式： 增量 delta 格式： 如 399334856af4ca4b49c0008a25b6a9f524e40350(SHA-1) 表示对象的 base object SHA-1 是 cb5a93c4cf9c0ee5b7153a3a35a4fac7a7584804，base 对象最大深度 (depth) 为 1，如果cb5a93c4cf9c0ee5b7153a3a35a4fac7a7584804 还有引用对象，则改变 depth 为 2。 pack Header 中最后 4-bytes 用于表示的 pack 文件中 objects 的数量，最多 2 的 32 次方个对象，所以一些大的工程中有多个 pack 文件和多个 idx 文件。 文件的 size (文件解压缩后大小) 有什么用呢，这个是为了方便我们进行解压的时候，设置流的大小，也就是方便知道流有多大。这里 size 不是说明下一个文件的偏移量，偏移量都是来自索引文件，见下面 idx： 由于 version1 比较简单，下面用 version2 为例子： 分层模式：Header，Fanout,SHA，CRC，Offset，Big File Offset，Trailer。 Header 层 version2 的 Header 部分总共有 8-bytes，version 1 的 header 部分是没有的，前 4-bytes 总是 255, 116, 79, 99 因为这个也是版本 1 的开头四个字节，后面 4-bytes 用于表示的是版本号，在当前就是 version 2。 Fanout 层 fanout 层是 git 的亮点设计，也叫 Fanout Table（扇表）。fanout 数组中存储的是相关对象的数目，数组下标是对应 16 进制数。fanout 最后一个存储的是整个 pack 文件中所有对象的总数量。Fanout Table 是整个 git 检索的核心，通过它我们可以快速进行查询，用于定位 SHA 层的数组起始 - 终止下标，定位好 SHA 层范围之后，就可以对 SHA 层进行二分查找了，而不用对所有对象进行二分查找。 fanout 总共 256 个，刚好是十六进制的 #0xFF。fanout 数组用 SHA 的前面 2 个字符作为下标(对应 .git/objects 中的松散文件目录名，将 16 进制的目录名转换 10 进制数字)，里面值就是用这两个字符开头的文件数量，而且是逐层累加的，后面的数组数量是包含前面数组的数据的个数的一个累加。 举例如下：1）如果数组下标为 0，且 Fanout[0] = 10 代表着 #0x00 开头的 SHA-1 值的总数为 10 个。 2） 如果数组下标为 1，且 Fanout[1] = 15 代表着小于 #0x01 开头的 SHA-1 值的总数为 15 个，从 Fanout[0] = 10 知 Fanout[1] = （15-10） 为什么 git 设计上 Fanout[n] 会累加 Fanout[n-1] 的数量？这个主要是为了快速确定 SHA 层检索的初始位置，而不用每次去把前面所有 fanout[..n-1] 数量进行累加。 SHA 层 是所有对象的 SHA-1 的排序，按照名称排序，按照名称进行排序是为了用二分搜索进行查找。每个 SHA-1 值占 20-bytes。 CRC 层 由于文件打包主要解决网络传输问题，网络传输的时候必须通过 crc 进行校验，避免传输过程中的文件损坏。CRC 数组对应的是每个对象的 CRC 校验和。 Offset 层 是由 4 byte 字节所组成，表示的是每个 SHA-1 文件的偏移量，但是如果文件大于 2G 之后，4 byte 字节将无法表示，此时将： 4 byte 中的第一 bit 就是 MSB，如果是 1 表示的是文件的偏移量是放在第 6 层去存储，此时剩下的 31-bits 将表示文件在 Big File Offset 中的偏移量，也就是图中的，通过 Big File Offset 层 就可以知道对象在 pack 中的 offset。 4 byte 中的第一 bit 就是 MSB，如果是 0 31-bits 表示的存储对象在 packfile 中的文件偏移量，此时不涉及 Big File Offset 层 Big File Offset 层 用于存储大于 2G 的文件的偏移量。如果文件大于 2G，可以通过 offset 层最后 31 bits 决定在 big file offset 中的位置，big file offset 通过 8 bytes 来表示对象在 pack 文件中的位置，理论上可以表示 2 的 64 次方文件大小。 Trailer 层 包含的是 packfile checksum 和关联的 idx 的 checksum。 索引流程 从上面的分层知道 git 设计的巧妙。git 索引文件偏移量的查询流程如下： 查询算法通过 idx 文件查询 SHA-1 对应的偏移量： 在 pack 文件中通过偏移量找到对象： 如果是普通的存储类型。定位到的对象就是用 Zlib 压缩之后的对象，直接解压缩即可。 如果是 Delta 类型需要 递归查出 Delta 的 Base 对象，然后再把 delta data 应用到 base object 上(可参考 git-apply-delta)。

如何实现面向对象？ 熟悉Lua的同学都知道！在Lua内部已经实现了面向对象的基本机制(table), 同时也为宿主语言（在这里是C语言）提供了一套接口来实现自定义数据结构（userdata）。在此，我们可以简单的利用metatable与__index的访问机制，为userdata实现一套简单的面向对象的访问方式。 stu.c main.lua 运行结果： 运行结果很简单。现在，我们简要分析一下具体实现步奏。 首先我们在注册表创建了一个metatable,并且起名"stu"。然后为这个元表添加一个__index元方法，然后将自身作为键值查找域。最后使用setfuncs为元表注入方法。 上述步奏等效于lua中如下操作： 这里需要注意的是：

AF.h 可以ctrl+shift+f找~

二维数组

注释非常详细，希望对你有所帮助。#include<stdio.h> #include<stdlib.h> #define M 15 #define N 15 struct mark //定义迷宫内点的坐标类型 { int x; int y; }; struct Element //"恋"栈元素，嘿嘿。。 { int x,y; //x行,y列 int d; //d下一步的方向 }; typedef struct LStack //链栈 { Element elem; struct LStack *next; }*PLStack; /*************栈函数****************/ int InitStack(PLStack &S)//构造空栈 { S=NULL; return 1; } int StackEmpty(PLStack S)//判断栈是否为空 { if(S==NULL) return 1; else return 0; } int Push(PLStack &S, Element e)//压入新数据元素 { PLStack p; p=(PLStack)malloc(sizeof(LStack)); p->elem=e; p->next=S; S=p; return 1; } int Pop(PLStack &S,Element &e) //栈顶元素出栈 { PLStack p; if(!StackEmpty(S)) { e=S->elem; p=S; S=S->next; free(p); return 1; } else return 0; } /***************求迷宫路径函数***********************/ void MazePath(struct mark start,struct mark end,int maze[M][N],int diradd[4][2]) { int i,j,d;int a,b; Element elem,e; PLStack S1, S2; InitStack(S1); InitStack(S2); maze[start.x][start.y]=2; //入口点作上标记 elem.x=start.x; elem.y=start.y; elem.d=-1; //开始为-1 Push(S1,elem); while(!StackEmpty(S1)) //栈不为空 有路径可走 { Pop(S1,elem); i=elem.x; j=elem.y; d=elem.d+1; //下一个方向 while(d<4) //试探东南西北各个方向 { a=i+diradd[d][0]; b=j+diradd[d][1]; if(a==end.x && b==end.y && maze[a][b]==0) //如果到了出口 { elem.x=i; elem.y=j; elem.d=d; Push(S1,elem); elem.x=a; elem.y=b; elem.d=886; //方向输出为-1 判断是否到了出口 Push(S1,elem); printf(" 0=东 1=南 2=西 3=北 886为则走出迷宫 通路为:(行坐标,列坐标,方向) "); while(S1) //逆置序列 并输出迷宫路径序列 { Pop(S1,e); Push(S2,e); } while(S2) { Pop(S2,e); printf("-->(%d,%d,%d)",e.x,e.y,e.d); } return; //跳出两层循环，本来用break,但发现出错，exit又会结束程序，选用return还是不错滴} if(maze[a][b]==0) //找到可以前进的非出口的点 { maze[a][b]=2; //标记走过此点 elem.x=i; elem.y=j; elem.d=d; Push(S1,elem); //当前位置入栈 i=a; //下一点转化为当前点 j=b; d=-1; } d++; } } printf("没有找到可以走出此迷宫的路径 "); } /*************建立迷宫*******************/ void initmaze(int maze[M][N]) { int i,j; int m,n; //迷宫行,列 [/M] printf("请输入迷宫的行数 m="); scanf("%d",&m); printf("请输入迷宫的列数 n="); scanf("%d",&n); printf(" 请输入迷宫的各行各列: 用空格隔开,0代表路,1代表墙 ",m,n); for(i=1;i<=m;i++) for(j=1;j<=n;j++) scanf("%d",&maze[i][j]); printf("你建立的迷宫为(最外圈为墙)... "); for(i=0;i<=m+1;i++) //加一圈围墙 { maze[i][0]=1; maze[i][n+1]=1; } for(j=0;j<=n+1;j++) { maze[0][j]=1; maze[m+1][j]=1; } for(i=0;i<=m+1;i++) //输出迷宫 { for(j=0;j<=n+1;j++) printf("%d ",maze[i][j]); printf(" "); } } void main() { int sto[M][N]; struct mark start,end; //start,end入口和出口的坐标 int add[4][2]={{0,1},{1,0},{0,-1},{-1,0}};//行增量和列增量 方向依次为东西南北 [/M] initmaze(sto);//建立迷宫 printf("输入入口的横坐标,纵坐标[逗号隔开] "); scanf("%d,%d",&start.x,&start.y); printf("输入出口的横坐标,纵坐标[逗号隔开] "); scanf("%d,%d",&end.x,&end.y); MazePath(start,end,sto,add); //find path system("PAUSE"); } 测试数据，算法复杂度你就自己来写吧，如果你连这都不自己做，那你一定是在应付作业。劝你还是自己运行测试一下吧，免得答辩时老师问你，什么都不知道，那你就悲剧了。祝你好运！！

#include <stdio.h>#include <stdlib.h>#include <time.h>#include <memory.h>/* define the size of maze */#define MAX_COL 6#define MAX_ROW 6#define TRUE 1#define FALSE 0#define IS_USABLE(a, b) (a >= 0 && a < MAX_ROW) && (b >= 0 && b < MAX_COL) && maze[a][b] && (!my_maze[a][b])static int maze[MAX_ROW][MAX_COL];static int target_maze[MAX_ROW][MAX_COL];static void init_maze();static int move_to(int i, int j, int (*maze)[MAX_COL], int count);static void print_maze(int (*maze)[MAX_COL]);static void init_maze(){ int i, j; srand((unsigned) time(NULL)); for (i = 0; i < MAX_ROW; i++) for(j = 0; j < MAX_COL; j++) { maze[i][j] = (int) (rand() % 2); } maze[1][0] = 1; /* start point */ maze[MAX_ROW - 1][MAX_COL - 2] = 1; /* end point */}static int move_to(int _i,int _j, int (*in_maze)[MAX_COL], int count) { int my_maze[MAX_ROW][MAX_COL], i, j; if (!in_maze) { for (i = 0; i < MAX_ROW; i++) for(j = 0; j < MAX_COL; j++) { my_maze[i][j] = 0; } } else { for (i = 0; i < MAX_ROW; i++) for(j = 0; j < MAX_COL; j++) { my_maze[i][j] = in_maze[i][j]; } } my_maze[_i][_j] = count; /* reach the end point */ if (_i == MAX_ROW - 1 && _j == MAX_COL - 2) { for (i = 0; i < MAX_ROW; i++) for(j = 0; j < MAX_COL; j++) { target_maze[i][j] = my_maze[i][j]; } return TRUE; } if (IS_USABLE(_i - 1, _j)) { if (move_to(_i - 1, _j, my_maze, count + 1)) return TRUE; } if (IS_USABLE(_i + 1, _j)) { if (move_to(_i + 1, _j, my_maze, count + 1)) return TRUE; } if (IS_USABLE(_i, _j - 1)) { if (move_to(_i, _j - 1, my_maze, count + 1)) return TRUE; } if (IS_USABLE(_i, _j + 1)) { if (move_to(_i, _j + 1, my_maze, count + 1)) return TRUE; } return FALSE;}static void print_maze(int (*maze)[MAX_COL]) { int i, j; for (i = 0; i < MAX_ROW; i++) { for(j = 0; j < MAX_COL; j++) { if (maze[i][j] != 0) printf("%d ", maze[i][j]); else printf(" "); } printf(" "); }}int main(){ while(1) { init_maze(); printf("Out put the maze : "); print_maze(maze); if (move_to(1, 0, NULL, 1)) { printf("Out put the path : "); print_maze(target_maze); break; } else { printf("No way! "); } }}VC60下正常运行

我只有C++的～～#include<iostream>#include<string>using namespace std;#define MaxVertexNum 50 /*景点个数最大50*/#define MAXCOST 1000 /*定义路径的无穷大*/#define T 8 /*目前景点个数*/typedef struct{ char name[20]; /*景点名称*/ char number[15]; /*景点代号*/ char introduce[100]; /*景点简介*/}Elemtype;typedef struct{ int num; /*顶点编号*/ Elemtype date; /*顶点信息*/}Vertex; /*定义顶点*/typedef struct{ Vertex vexs[MaxVertexNum]; /*存放顶点的一维数组,数组第零个单元没有用上*/ unsigned int edges[MaxVertexNum][MaxVertexNum]; /*存放路径的长度*/ int n,e;}MGraph;MGraph MGr; /*全局变量,定义MGr为MGraph类型*/int shortest[MaxVertexNum][MaxVertexNum]; /*定义全局变量存贮最小路径*/int path[MaxVertexNum][MaxVertexNum]; /*定义存贮路径*/void init(){ int i,j; MGr.vexs[1].num=1; strcpy(MGr.vexs[1].date.name,"学校东门"); strcpy(MGr.vexs[1].date.number,"001"); strcpy(MGr.vexs[1].date.introduce,"挨着三好街，购物很方便。"); MGr.vexs[2].num=2; strcpy(MGr.vexs[2].date.name,"综合楼"); strcpy(MGr.vexs[2].date.number,"002"); strcpy(MGr.vexs[2].date.introduce,"学校最新的大楼。"); MGr.vexs[3].num=3; strcpy(MGr.vexs[3].date.name,"逸夫楼"); strcpy(MGr.vexs[3].date.number,"003"); strcpy(MGr.vexs[3].date.introduce,"上课的地方。"); MGr.vexs[4].num=4; strcpy(MGr.vexs[4].date.name,"教学馆"); strcpy(MGr.vexs[4].date.number,"004"); strcpy(MGr.vexs[4].date.introduce,"上课的地方。"); MGr.vexs[5].num=5; strcpy(MGr.vexs[5].date.name,"篮球场"); strcpy(MGr.vexs[5].date.number,"005"); strcpy(MGr.vexs[5].date.introduce,"打篮球的地方。"); MGr.vexs[6].num=6; strcpy(MGr.vexs[6].date.name,"大活"); strcpy(MGr.vexs[6].date.number,"006"); strcpy(MGr.vexs[6].date.introduce,"开晚会搞活动的地方。"); MGr.vexs[7].num=7; strcpy(MGr.vexs[7].date.name,"汉卿会堂"); strcpy(MGr.vexs[7].date.number,"007"); strcpy(MGr.vexs[7].date.introduce,"开讲座的地方。"); MGr.vexs[8].num=8; strcpy(MGr.vexs[8].date.name,"主楼"); strcpy(MGr.vexs[8].date.number,"008"); strcpy(MGr.vexs[8].date.introduce,"做实验的地方。"); for(i=1;i<=T;i++) { for(j=1;j<=T;j++) { MGr.edges[i][j]=MAXCOST; } } for(i=1;i<=T;i++) { shortest[i][i]=0; } /*初始化*/ MGr.edges[1][2]=MGr.edges[2][1]=25; MGr.edges[1][5]=MGr.edges[5][1]=15; MGr.edges[1][3]=MGr.edges[3][1]=10; MGr.edges[2][8]=MGr.edges[8][2]=30; MGr.edges[5][7]=MGr.edges[7][5]=32; MGr.edges[7][8]=MGr.edges[8][7]=12; MGr.edges[6][7]=MGr.edges[7][6]=6; MGr.edges[3][4]=MGr.edges[4][3]=24; MGr.edges[4][6]=MGr.edges[6][4]=50; MGr.edges[1][1]=MGr.edges[2][2]=MGr.edges[3][3]=MGr.edges[4][4]=0; MGr.edges[5][5]=MGr.edges[6][6]=MGr.edges[7][7]=MGr.edges[8][8]=0;} void introduce(){ int n; cout<<"请输入查询景点编号："<<endl; cin>>n; switch(n) { case 1: cout<<"景点编号："<<MGr.vexs[1].date.number<<"景点名称："<<MGr.vexs[1].date.name; cout<<"景点简介："<<MGr.vexs[1].date.introduce<<endl; break; case 2: cout<<"景点编号："<<MGr.vexs[2].date.number<<"景点名称："<<MGr.vexs[2].date.name; cout<<"景点简介："<<MGr.vexs[2].date.introduce<<endl; break; case 3: cout<<"景点编号："<<MGr.vexs[3].date.number<<"景点名称："<<MGr.vexs[3].date.name; cout<<"景点简介："<<MGr.vexs[3].date.introduce<<endl; break; case 4: cout<<"景点编号："<<MGr.vexs[4].date.number<<"景点名称："<<MGr.vexs[4].date.name; cout<<"景点简介："<<MGr.vexs[4].date.introduce<<endl; break; case 5: cout<<"景点编号："<<MGr.vexs[5].date.number<<"景点名称："<<MGr.vexs[5].date.name; cout<<"景点简介："<<MGr.vexs[5].date.introduce<<endl; break; case 6: cout<<"景点编号："<<MGr.vexs[6].date.number<<"景点名称："<<MGr.vexs[6].date.name; cout<<"景点简介："<<MGr.vexs[6].date.introduce<<endl; break; case 7: cout<<"景点编号："<<MGr.vexs[7].date.number<<"景点名称："<<MGr.vexs[7].date.name; cout<<"景点简介："<<MGr.vexs[7].date.introduce<<endl; break; case 8: cout<<"景点编号："<<MGr.vexs[8].date.number<<"景点名称："<<MGr.vexs[8].date.name; cout<<"景点简介："<<MGr.vexs[8].date.introduce<<endl; break; default: cout<<"输入序号错误。"; break; }}void floyd(){ int i,j,k; for(i=1;i<=T;i++) { for(j=1;j<=T;j++) { shortest[i][j]=MGr.edges[i][j]; path[i][j]=0; } } /*初始化数组*/ for(k=1;k<=T;k++) { for(i=1;i<=T;i++) { for(j=1;j<=T;j++) { if(shortest[i][j]>(shortest[i][k]+shortest[k][j])) { shortest[i][j]=shortest[i][k]+shortest[k][j]; path[i][j]=k; path[j][i]=k;/*记录经过的路径*/ }//end_if } } }//end_for}void display(int i,int j){/* 打印两个景点的路径及最短距离 */ int a,b; a=i; b=j; cout<<"您要查询的两景点间最短路径是: "; if(shortest[i][j]!=MaxVertexNum) { if(i<j) { cout<<b; while(path[i][j]!=0) {/* 把i到j的路径上所有经过的景点按逆序打印出来*/ cout<<"<-"<<path[i][j]; if(i<j) j=path[i][j]; else i=path[j][i]; } cout<<"<-"<<a; cout<<" "; cout<<a<<"->"<<b<<"最短距离是"<<shortest[a][b]<<"米"<<" "; } else { cout<<a; while(path[i][j]!=0) {/* 把i到j的路径上所有经过的景点按顺序打印出来*/ cout<<"->"<<path[i][j]; if(i<j) j=path[i][j]; else i=path[j][i]; } cout<<"->"<<b; cout<<" "; cout<<a<<"->"<<b<<"最短距离是:"<<shortest[a][b]<<"米 "<<endl; } } else cout<<"输入错误！不存在此路！ "; }/*display*/int shortestdistance(){/*要查找的两景点的最短距离*/ int i,j; cout<<"请输入要查询的两个景点的编号(1->8的数字编号并用" "间隔):"; cin>>i>>j; if(i>T||i<=0||j>T||j<0) { cout<<"输入信息错误！ "; cout<<" 请输入要查询的两个景点的编号(1->8的数字编号并用" "间隔): "; cin>>i>>j; } else { floyd(); display(i,j); } return 1;}/*shortestdistance*/void main(){ char k; init(); cout<<"******************************************************************* "; cout<<"* * "; cout<<"* * "; cout<<"* 欢迎使用校园导游咨询 * "; cout<<"* * "; cout<<"****************************************************************** "; while(1) { cout<<"1.景点信息查询请按 i 键 "; cout<<"2.景点最短路径查询请按 s 键 "; cout<<"3.退出系统请按 e 键 "; cout<<"请选择服务:"; cin>>k; switch(k) { case "i": cout<<"景点简介查询（请输入1~8）。"; introduce(); break; case "s": cout<<"景点最短路径查询。"; shortestdistance(); break; case "e": exit(0); } }system("pause");}

建议还是拿本数据结构或者算法的书出来照着搞，图论的东西都是比较复杂的，多练练手对你有好处

深度优先。

//思路:先把邻接表转换成逆邻接表，这样问题简单多了。//数组out，保存各节点的入度voidcountindegree(AdjListgin,AdjListgout){//设有向图有n个顶点，建逆邻接表的顶点向量。for(inti=1;i<=n;i++){gin[i].vertex=gout[i].vertex;gin.firstarc=null;}//邻接表转为逆邻接表。for(i=1;i<=n;i++){p=gout[i].firstarc;//取指向邻接表的指针。while(p!=null){j=p->adjvex;s=(ArcNode*)malloc(sizeof(ArcNode));//申请结点空间。s->adjvex=i;s->next=gin[j].firstarc;gin[j].firstarc=s;p=p->next;//下一个邻接点。}//while}//endoffor//统计各节点的入度for(i=0;i<n;i++){p=gin[i].firstarc;while(p!=null){out[i]++;p=p->next;}//endofwhile}//endoffor}//endoffunction

题不具体根本就没有办法做嘛？你最好把题完全的打上来，这样就可以做了

贪婪算法（Greedy）的定义：是一种在每一步选中都采取在当前状态下最好或最优的选择，从而希望导致结果是全局最好或最优的算法。 贪婪算法：当下做局部最优判断，不能回退 （能回退的是回溯，最优+回退是动态规划） 由于贪心算法的高效性以及所求得答案比较接近最优结果，贪心算法可以作为辅助算法或解决一些要求 结果不特别精确的问题 注意：当下是最优的，并不一定全局是最优的。举例如下： 有硬币分值为10、9、4若干枚，问如果组成分值18，最少需要多少枚硬币？ 采用贪心算法，选择当下硬币分值最大的：10 18-10=8 8/4=2 即：1个10、2个4，共需要3枚硬币 实际上我们知道，选择分值为9的硬币，2枚就够了 18/9=2 如果改成： 背包问题是算法的经典问题，分为部分背包和0-1背包，主要区别如下： 部分背包：某件物品是一堆，可以带走其一部分 0-1背包：对于某件物品，要么被带走（选择了它），要么不被带走（没有选择它），不存在只带走一部分的情况。 部分背包问题可以用贪心算法求解，且能够得到最优解。 假设一共有N件物品，第 i 件物品的价值为 Vi ，重量为Wi，一个小偷有一个最多只能装下重量为W的背包，他希望带走的物品越有价值越好，可以带走某件物品的一部分，请问：他应该选择哪些物品？ 假设背包可容纳50Kg的重量，物品信息如下表： 将物品按单位重量 所具有的价值排序。总是优先选择单位重量下价值最大的物品 按照我们的贪心策略，单位重量的价值排序： 物品A > 物品B > 物品C 因此，我们尽可能地多拿物品A，直到将物品1拿完之后，才去拿物品B，然后是物品C 可以只拿一部分..... 在不考虑排序的前提下，贪心算法只需要一次循环，所以时间复杂度是O(n) 优点：性能高，能用贪心算法解决的往往是最优解 缺点：在实际情况下能用的不多，用贪心算法解的往往不是最好的 针对一组数据，我们定义了限制值和期望值，希望从中选出几个数据，在满足限制值的情况下，期望值最大。 每次选择当前情况下，在对限制值同等贡献量的情况下，对期望值贡献最大的数据（局部最优而全局最优） 大部分能用贪心算法解决的问题，贪心算法的正确性都是显而易见的，也不需要严格的数学推导证明 在实际情况下，用贪心算法解决问题的思路，并不总能给出最优解

离散数学-》数据结构-》操作系统-》汇编原理-》编译原理汇编原理之前还有们微机原理，要学的东西很多，这几门都能学好已经“很"不错了

先学离散数学和操作系统原理做为基础,再学汇编语言,然后学数据结构

数据结构是相对微观的概念，它的研究对象是数据在计算机中的存储结构和组织数据的方式。对程序员而言，要想编写出高质量的代码（既能使编写的代码高效、又能便于阅读、差错），这就需要很深的数据结构功底了。这种与编写程序息息相关的一门学科，建议先学为佳。操作系统原理是个宏观概念，其涉及面相当广泛。对操作系统而言所称的“数据结构”实际上是系统内部结构，包括文件系统、设备管理模块、内存管理模块、用户UI模块、安全机制、网络通信模块等等。里面讲解的东西很多都是属于理论层面的，比较抽象，编程结合得不是很紧密。所以建议放在后面来学。

数据库原理,数据结构比较重要我这里有些,希望对你有用,最近我也在看,我大二了,也准备考研 这是学科,就是你要上的专业,后面说考试内容 计算机系统结构 02 网络与信息安全 04 计算机通信，信息安全，多媒 体信号处理 05 图形图像处理技术 07 计算机图形图像处理技术、嵌 入式系统 09 计算机网络与图形图像处理 10 计算机网络与信息处理 11 输入输出技术与设备、图像处 理与图像理解 12 信息安全理论与技术,嵌入式系统 13 网络安全 14 信息安全与编码 15 网络安全和网络计算 16 图形图像和外设 17 计算机输入输出技术与设备、 图形图像处理与理解 考试科目: ①101政治理论②201英语③301数学（一）④431计算机基础(计算机基础包含离散数学45分；数据结构45分；计算机组成原理60分) 计算机软件与理论 02 面向对象技术 04 软件安全与编译器体系结构 06 分布计算与互联网技术 08 并行与分布计算，生物信息学算法 09 软件工程、信息系统 10 软件理论与应用 11 高可信软件技术、互联网计算与互联网 软件、可编程芯片支持软件和嵌入式系统 12 软件测试与自演化技术 14 程序理解、软件再工程 15 计算智能的理论、方法与应用 16 高可信软件技术、互联网计算与互联网软 件、可编程芯片支持软件和嵌入式系统 考试科目: ①101政治理论②201英语③301数学（一）④431计算机基础(计算机基础包含离散数学45分；数据结构45分；计算机组成原理60分) 计算机应用技术 02 多媒体信息处理 03 智能信息处理、网络多媒体与 虚拟仿真技术 05 图形图像处理、虚拟仿真与网络安全 06 网络智能信息处理、模式识别 与人工智能 07 智能信息处理、生物信息处理 08 网络数据库与智能检测 09 嵌入式系统及应用 10 图像传输与处理 11 计算生物学、生物信息领域的 数据挖掘 12 计算机控制系统与IC设计技术 13 网络与智能信息处理 15 计算机应用 ①101政治理论②201英语③301数学（一）④431计算机基础(计算机基础包含离散数学45分；数据结构45分；计算机组成原理60分) 政治,英语,数学是必考的,没有讨价的余地 一般都是考的基础课,比如:数据结构,操作系统,计算机系统结构,编译原理,离散数学,计算机网络等.各个学校的考试科目是有差异的,你要想报考哪个学校,就登陆他们的网站,查看研究生招生简章和专业目录,那里注明的比较清楚. 我觉的,考计算机最重要两们课,数据结构,离散数学 你要考哪个学校的,去他们网站上看考研的招生简章,我也是在各个网站上搜集到的 希望对你有帮助

现在数据库一般分为两种:关系型数据库,比如现在常用的oracle,mysql等.再就是非关系型数据库,比较新兴,用的公司比较少,比较提倡面向对象,前段时间google就换了这种.数据库就是数据的存储,用哪种数据结构存储会有不一样的效果.两者关系硬要说的话,数据结构比较基础.

打开msdn，输入关键字CFontCFont这个类就是VC中对字体的一种抽象绝对能满足你的要求

数据结构是电脑里数据的组织方式,或者说存储方式,是一种什么结构来存取数据,例如典型的堆栈结构stack,队列结构queue，链表结构list等，堆栈是后进先出lastinfirstout（lifo），队列结构是firstinfirstout(fifo)，链表是任意位置插入新数据之类的，简单来说就是找一种方式方便你存取你的数据。数据库是一个数据集合，顾名思义，库就是一个存储地方嘛，即存放大量数据的地方，而往数据库里放数据或者访问数据库里的数据的方式就是数据结构的内容了。数据库相当于一个容器，数据结构相当于你往容器里放东西的方式和取东西的方式，如果没有数据结构，那么容器里的东西（数据）就会杂乱无章，以后取出来也麻烦。两个理念，一句两句说不清楚，重要的是看书

import java.util.Arrays;import java.util.Comparator;import java.util.HashMap;import java.util.Scanner;import java.util.Stack;import java.util.Vector;import java.util.regex.MatchResult;public class Test { private CarStop carStop = new CarStop(3); private CarTunnel tunnel = new CarTunnel(); public void test(){ //存放车辆信息，因为不是顺序输入的，所以放到Map中 HashMap<Integer, Car> carMap = new HashMap<Integer, Car>(); //最早进入车库的时间和最晚出车库的时间 int startTime, endTime; startTime = Integer.MAX_VALUE; endTime = Integer.MIN_VALUE; Scanner scanner = new Scanner(System.in); //("A"或者"D"或者"E", int, int) while(scanner.hasNext("\((A|D|E),(\d+),(\d+)\)")){ scanner.next("\((A|D|E),(\d+),(\d+)\)"); MatchResult r = scanner.match(); Car car; //如果输入A if (r.group(1).equalsIgnoreCase("A")){// 该车已经记录过 if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){// 取出来设置到达时间 car = carMap.get(Integer.parseInt(r.group(2))); car.arrive = Integer.parseInt(r.group(3)); }else{// 否则就记录该车 car = new Car(Integer.parseInt(r.group(2)), Integer.parseInt(r.group(3))); carMap.put(car.no, car); } if (car.arrive < startTime) startTime = car.arrive; if (car.leave > endTime) endTime = car.leave;// 出库时间和到达时间同样处理 }else if (r.group(1).equalsIgnoreCase("D")){ if (carMap.keySet().contains(Integer.parseInt(r.group(2)))){ car = carMap.get(Integer.parseInt(r.group(2))); car.leave = Integer.parseInt(r.group(3)); }else{ car = new Car(Integer.parseInt(r.group(2)), 0, Integer.parseInt(r.group(3))); carMap.put(car.no, car); } if (car.arrive < startTime) startTime = car.arrive; if (car.leave > endTime) endTime = car.leave; }else if (r.group(1).equalsIgnoreCase("E")){ break; } }// 把记录过的车做成数组并且排序 Car[] cars = new Car[carMap.size()]; cars = carMap.values().toArray(cars); Arrays.sort(cars, new Comparator<Car>(){// 排序顺序是到达时间>出库时间>车牌 public int compare(Car c1, Car c2) { if (c1.arrive!=c2.arrive) return c1.arrive - c2.arrive; if (c1.leave!=c2.leave) return c1.leave - c2.leave; return c1.no - c2.no; } }); for (int time=startTime; time<=endTime; time++){ System.out.println("TIME:" + time); for (int k=0;k<cars.length;k++){ Car car = cars[k]; //如果有车在没有进入停车场的时候就已经到了出库时间 if (car.leave == time && carStop.isFull() && !carStop.contains(car)){ for (int i=tunnel.size()-1;i>=0;i--){ Car c = tunnel.get(i); if (c.equals(car)){ for (int j=i+1;j<tunnel.size();j++){ System.out.println(car + "为" + car + "让路，重新进入等待区"); } tunnel.remove(car); System.out.println(car + "没进入过停车场就离开了"); }else{ System.out.println(car + "为" + car + "让路"); } } }else{// 如果有车子现在到达 if (car.arrive == time){// 停车场不满 if (!carStop.isFull()) {// 进入停车场 carStop.push(car);// 开始计费 car.chargeStart = time; System.out.println(car + "进入停车场并且开始计费"); }else{// 停车场满，等待 System.out.println(car + "到达，在等待区等待"); tunnel.push(car); } } } } //deal with cars in stop //the case cars leave at same time is not included // 按照后进先出的顺序看有没有车要离开 for (int k=carStop.size() - 1; k>=0; k--){ Car car = carStop.elementAt(k); //准备离开 if (car.leave == time){ Car otherCar;// 所有在他后面进来的车准备让路 while ((otherCar = carStop.pop())!=car){// 进入等待区的最前面 tunnel.unshift(otherCar); System.out.println(otherCar + "准备为" + car + "让路"); } for (int m=tunnel.size()-1;m>=0;m--){ System.out.println(tunnel.elementAt(m) + "为" + car + "让路"); } System.out.println(otherCar + "离开，停车时间:" + (otherCar.leave - otherCar.chargeStart)); for (int m=0; m<tunnel.size(); m++){ System.out.println(tunnel.elementAt(m) + "让路完毕，重新进入等待区"); } Car waitingCar; //停车场有空位，等待序列最前面的车入库 while ( !carStop.isFull() && (waitingCar = tunnel.shift())!=null ){ carStop.push(waitingCar);// 停车计时开始 if (waitingCar.chargeStart == -1) { System.out.println(waitingCar + "停车计时时间改为:" + time); waitingCar.chargeStart = time; } System.out.println(waitingCar + "进入停车场"); } } } } } public static void main(String[] args){ new Test().test(); }}@SuppressWarnings("serial")class CarTunnel extends Vector<Car>{ public CarTunnel(){ super(); } public Car shift(){ if (size() == 0) return null; return remove(0); } public void unshift(Car car){ super.add(0, car); } public void push(Car car){ super.add(car); } public Car pop(){ if (size() == 0) return null; return remove(size()-1); }}@SuppressWarnings("serial")class CarStop extends Stack<Car>{ private int size; public CarStop(int size){ this.size = size; } public boolean isFull(){ return size() == size; } public Car pop(){ return super.pop(); } public Car push(Car car){ if (size() <= size){ return super.push(car); }else{ return null; } }}class Car{ public int no; public int arrive; public int leave; public int chargeStart = -1; public Car(int no, int timeIn, int timeOut){ this.no = no; this.arrive = timeIn; this.leave = timeOut; } public Car(int no, int timeIn){ this(no, timeIn, -1); } public String toString(){ return String.format("Car(%d)", no); }}结果：(A,6,31)(A,5,30)(A,4,20)(A,3,16)(A,2,15)(A,1,10)(D,1,50)(D,2,30)(D,3,31)(D,4,25)(D,5,32)(D,6,40)(E,0,0)TIME:10Car(1)进入停车场并且开始计费TIME:11TIME:12TIME:13TIME:14TIME:15Car(2)进入停车场并且开始计费TIME:16Car(3)进入停车场并且开始计费TIME:17TIME:18TIME:19TIME:20Car(4)到达，在等待区等待TIME:21TIME:22TIME:23TIME:24TIME:25Car(4)没进入过停车场就离开了TIME:26TIME:27TIME:28TIME:29TIME:30Car(5)到达，在等待区等待Car(3)准备为Car(2)让路Car(5)为Car(2)让路Car(3)为Car(2)让路Car(2)离开，停车时间:15Car(3)让路完毕，重新进入等待区Car(5)让路完毕，重新进入等待区Car(3)进入停车场Car(5)停车计时时间改为:30Car(5)进入停车场TIME:31Car(6)到达，在等待区等待Car(5)准备为Car(3)让路Car(6)为Car(3)让路Car(5)为Car(3)让路Car(3)离开，停车时间:15Car(5)让路完毕，重新进入等待区Car(6)让路完毕，重新进入等待区Car(5)进入停车场Car(6)停车计时时间改为:31Car(6)进入停车场TIME:32Car(6)准备为Car(5)让路Car(6)为Car(5)让路Car(5)离开，停车时间:2Car(6)让路完毕，重新进入等待区Car(6)进入停车场TIME:33TIME:34TIME:35TIME:36TIME:37TIME:38TIME:39TIME:40Car(6)离开，停车时间:9TIME:41TIME:42TIME:43TIME:44TIME:45TIME:46TIME:47TIME:48TIME:49TIME:50Car(1)离开，停车时间:40

数组、链表、栈、二叉树。

#include <stdio.h>#include <stdlib.h>#include <string.h>typedef int DataType;typedef struct node{ DataType data; struct node * next;}Stack;Stack* CreateStack(); //创建栈void StackEmpty(Stack* ); //清空栈void DestoryStack(Stack*); //撤销(删除)栈int IsEmpty(Stack*); //判空int PushStack(Stack*, DataType); //入栈int PopStack(Stack*); //出栈DataType GetTopElement(Stack*); //取栈顶元素Stack* CreateStack(){ Stack *stack = (Stack*)malloc(sizeof(Stack)); if(NULL != stack) { stack->next = NULL; return stack; } printf("out of place. "); return NULL;}//清空栈void StackEmpty(Stack* stack){ while(!IsEmpty(stack)) { PopStack(stack); } printf("now stack is empty. ");}//撤销栈void DestoryStack(Stack* stack){ free(stack); exit(0);}int IsEmpty(Stack* stack){ return (stack->next == 0);}//入栈，成功返回1，失败返回0， 把元素 data 存入 栈 stack 中int PushStack(Stack* stack, DataType data){ Stack* newst = (Stack*)malloc(sizeof(Stack)); if(NULL != newst) { newst->data = data; newst->next = stack->next; //s->next = NULL; stack->next = newst; return 1; } printf("out of place PushStack. "); return 0;}/* 出栈，成功返回1，失败返回0，出栈不取出元素值，只是删除栈顶元素。 如出栈要实现，取出元素值，并释放空间，可结合取栈顶元素函数做修改，这里不再给出。 */int PopStack(Stack* stack){ Stack* tmpst; if(!IsEmpty(stack)) { tmpst = stack->next; stack->next = tmpst->next; free(tmpst); return 1; } return 0;}//取栈顶元素，仅取出栈顶元素的值，取出之后，该元素，任然存在栈中。成功返回元素值，失败输出提示信息，并返回 -1DataType GetTopElement(Stack* stack){ if(!IsEmpty(stack)) { return stack->next->data; } printf("stack is empty GetTopElement. "); return -1;}int main(){ Stack* stack = CreateStack(); char str[200]; printf("请输入字符串："); scanf("%s", str); int num = 0; for (int i = 0; i < strlen(str); i++) { if (!IsEmpty(stack) && GetTopElement(stack) == "(" && str[i] == ")") { PopStack(stack); num++; } else { PushStack(stack, str[i]); } } if (!IsEmpty(stack)) { num = -1; } printf("匹配结果：%d", num); DestoryStack(stack); return 1;}

好像很多变量和函数的定义不完整吧，应该是片段吧，感觉很简单的，我需要回答什么呀？

两个::表示作用域限定符。比如：stack::stack的第一个stack是类名或结构体名；第二个stack是构造函数名（c++规定构造函数要与类或结构体同名）；而::指定第二个stack是第一个类（或结构体）stack的构造函数，而不是其它类或结构体的构造函数。像这种语法主要用在在类或结构体的里面声明其成员，而在外面定义其成员的时候。比如：class student{public://构造函数的声明（在类内）student(string id,string name,int age);//下面两个是设置、获取学号函数的声明void setid(string id);string getid();//其它函数的声明（如有）//......//成员变量的声明private:int age;string id,name;};//构造函数的定义（在类外）student::student(string id,string name,int age){this->id=id;this->name=name;this->age=age;}//设置学号函数的定义（在类外）void student::setid(string id){this->id=id;}//获取学号函数的定义（在类外）string student::getid(){return id;}//其它函数的定义（在类外）//......

typedef int Status数据结构里讲的Status都是它。

struct是结构体类型

在 C 语言中，可以使用结构体（ Struct ）来存放一组不同类型的数据。结构体是一种集合，它里面包含了多个变量或数组，它们的类型可以相同，也可以不同，每个这样的变量或数组都称为结构体的成员（ Member ）。结构体的定义形式为： 结构体是一种自定义的数据类型，是创建变量的模板，不占用内存空间。结构体变量才包含了实实在在的数据，需要内存空间来存储。 stu 为结构体名，里面包含name、num、age、group、score这5个成员。 stu1 和 stu2 则为两个stu类型的结构体变量。 直接将变量放在结构体的最后即可。 如上所示，在 stu 结构体里还定义了『结构体变量sub1』和『结构体sub2』，由于 sub2 没有定义变量，所以其内部成员 score 即为母结构体stu的成员变量。 使用点号 . 获取结构体变量的单个成员，然后再进行赋值操作。 也可以在定义结构体变量时整体赋值： 结构体中各成员在内存中是按顺序依次存储的，成员之间不互相影响，各占用不同的内存空间。结构体变量占用的内存大于等于所有成员占用的内存的总和，因为成员在存储时需要遵循结构体的内存对齐规则，成员之间可能会存在裂缝。 先来看看结构体的内存对齐规则： 看完内存对齐规则是不是感觉有点绕？不急，接下来通过分析具体例子来理解这个规则。 示例1：含有多种数据类型成员 输出结果分析： 根据上面的分析可知，struct1的成员总共需要18字节内存，根据规则3，struct1的内存大小必须是8（double a）的整数倍，所以最后内存大小为24。 示例2：交换成员位置 这次在示例1中struct的基础上交换了成员b和c的位置，输出结果就不一样了，分析如下： 根据上面的分析可知，struct2的成员总共需要16字节内存，根据规则3，struct2的内存大小必须是8（double a）的整数倍，所以最后内存大小为16。 示例3：结构体嵌套结构体 直接在struct1里加上一个struct2成员，然后输出内存大小 从之前struct1的分析可知，a、b、c、d实际占用18字节（位置0-17），那成员e就需要从位置18开始存放。由于e是个结构体，根据规则2， 当结构体作为成员时，需要从其内部最u2f24元素所占内存u2f24u2f29的整数倍地址开始存储 。结构体e中内存占用最大的元素是 double a ，为8字节，所以e就需要从8的整数倍地址开始存储，即后移到位置24开始存储，e本身占用16字节内存，所以存放位置是24-39。 根据上面的分析可知，struct1的成员总共需要40字节内存，根据规则3，struct1的内存大小必须是8（double a）的整数倍，所以最后内存大小为40。 1. 数据结构 -- 共用体Union 2. 数据结构 -- 位域

具体如下：Sub过程：在一程序内执行特殊任务的过程，不返回显式值。Sub 过程以Sub 语句开头，以 End Sub 语句结尾。Sub 语句主要是声明子过程的名称、参数、以及构成其主体的代码。其语法如下：z[Private | Public | Friend] [Static] Sub name [(arglist)][statements][Exit Sub[statements]End Sub

tensor就是容纳推理框架中间数据的一个数据结构，常用的有关函数如下： 这其中第一个参数是tensor的维度信息，第二个参数是是否指定数据指针，第三个参数是数据在内存中的排布信息，如果是CAFFE证明是NCHW类型，如果是TENSORFLOW证明是NHWC类型，默认的类型是TENSORFLOW类型，这里经常会有一些坑，比如最终想要得到一个1 3 1024*1024的数据时候，如果没有指定是CAFFE类型的数据排布，而是使用默认的情况（TENSORFLOW），读出来的数据channel维度就在最后。 得到各种维度和长度： 得到shape向量和数据总数： 得到数据指针： Interpreter就是一个MNN的从模型得到的一个网络，有关Interpreter的tenosr操作，肯定就是涉及到输入的tesnor和输出的tensor的设置，由于可能在不同的设备上运行，因此可能有内存拷贝的操作。 获取Interpreter的输入tensor： 获取Interpreter的输出tensor： 将host的tensor数据拷贝给Interpreter的tensor 将Interpreter的tensor数据拷贝给host tensor

链表结构啦、树的遍历之类的~

数据结构复习重点归纳笔记[清华严蔚敏版]数据结构复习重点归纳[适于清华严版教材]一、数据结构的章节结构及重点构成数据结构学科的章节划分基本上为：概论，线性表，栈和队列，串，多维数组和广义表，树和二叉树，图，查找，内排，外排，文件，动态存储分配。对于绝大多数的学校而言，“外排，文件，动态存储分配”三章基本上是不考的，在大多数高校的计算机本科教学过程中，这三章也是基本上不作讲授的。所以，大家在这三章上可以不必花费过多的精力，只要知道基本的概念即可。但是，对于报考名校特别是该校又有在试卷中对这三章进行过考核的历史，那么这部分朋友就要留意这三章了。按照以上我们给出的章节以及对后三章的介绍，数据结构的章节比重大致为：概论：内容很少，概念简单，分数大多只有几分，有的学校甚至不考。线性表：基础章节，必考内容之一。考题多数为基本概念题，名校考题中，鲜有大型算法设计题。如果有，也是与其它章节内容相结合。栈和队列：基础章节，容易出基本概念题，必考内容之一。而栈常与其它章节配合考查，也常与递归等概念相联系进行考查。串 ：基础章节，概念较为简单。专门针对于此章的大型算法设计题很少，较常见的是根据KMP进行算法分析。多维数组及广义表 ：基础章节，基于数组的算法题也是常见的，分数比例波动较大，是出题的“可选单元”或“侯补单元”。一般如果要出题，多数不会作为大题出。数组常与“查找，排序”等章节结合来作为大题考查。树和二叉树 ：重点难点章节，各校必考章节。各校在此章出题的不同之处在于，是否在本章中出一到两道大的算法设计题。通过对多所学校的试卷分析，绝大多数学校在本章都曾有过出大型算法设计题的历史。图 ：重点难点章节，名校尤爱考。如果作为重点来考，则多出现于分析与设计题型当中，可与树一章共同构成算法设计大题的题型设计。查找 ：重点难点章节，概念较多，联系较为紧密，容易混淆。出题时可以作为分析型题目给出，在基本概念型题目中也较为常见。算法设计型题中可以数组结合来考查，也可以与树一章结合来考查。排序 ：与查找一章类似，本章同属于重点难点章节，且概念更多，联系更为紧密，概念之间更容易混淆。在基本概念的考查中，尤爱考各种排序算法的优劣比较此类的题。算法设计大题中，如果作为出题，那么常与数组结合来考查。二、数据结构各章节重点勾划：第0章 概述本章主要起到总领作用，为读者进行数据结构的学习进行了一些先期铺垫。大家主要注意以下几点：数据结构的基本概念，时间和空间复杂度的概念及度量方法，算法设计时的注意事项。本章考点不多，只要稍加注意理解即可。第一章 线性表作为线性结构的开篇章节，线性表一章在线性结构的学习乃至整个数据结构学科的学习中，其作用都是不可低估的。在这一章，第一次系统性地引入链式存储的概念，链式存储概念将是整个数据结构学科的重中之重，无论哪一章都涉及到了这个概念。总体来说，线性表一章可供考查的重要考点有以下几个方面：1.线性表的相关基本概念，如：前驱、后继、表长、空表、首元结点，头结点，头指针等概念。2.线性表的结构特点，主要是指：除第一及最后一个元素外，每个结点都只有一个前趋和只有一个后继。3.线性表的顺序存储方式及其在具体语言环境下的两种不同实现：表空间的静态分配和动态分配。静态链表与顺序表的相似及不同之处。4.线性表的链式存储方式及以下几种常用链表的特点和运算：单链表、循环链表，双向链表，双向循环链表。其中，单链表的归并算法、循环链表的归并算法、双向链表及双向循环链表的插入和删除算法等都是较为常见的考查方式。此外，近年来在不少学校中还多次出现要求用递归算法实现单链表输出（可能是顺序也可能是倒序）的问题。在链表的小题型中，经常考到一些诸如：判表空的题。在不同的链表中，其判表空的方式是不一样的，请大家注意。5.线性表的顺序存储及链式存储情况下，其不同的优缺点比较，即其各自适用的场合。单链表中设置头指针、循环链表中设置尾指针而不设置头指针以及索引存储结构的各自好处。第二章 栈与队列栈与队列，是很多学习DS的同学遇到第一只拦路虎，很多人从这一章开始坐晕车，一直晕到现在。所以，理解栈与队列，是走向DS高手的一条必由之路，。学习此章前，你可以问一下自己是不是已经知道了以下几点：1.栈、队列的定义及其相关数据结构的概念，包括：顺序栈，链栈，共享栈，循环队列，链队等。栈与队列存取数据（请注意包括：存和取两部分）的特点。2.递归算法。栈与递归的关系，以及借助栈将递归转向于非递归的经典算法：n!阶乘问题，fib数列问题，hanoi问题，背包问题，二叉树的递归和非递归遍历问题，图的深度遍历与栈的关系等。其中，涉及到树与图的问题，多半会在树与图的相关章节中进行考查。3.栈的应用：数值表达式的求解，括号的配对等的原理，只作原理性了解，具体要求考查此为题目的算法设计题不多。4.循环队列中判队空、队满条件，循环队列中入队与出队算法。如果你已经对上面的几点了如指掌，栈与队列一章可以不看书了。注意，我说的是可以不看书，并不是可以不作题哦。第三章 串经历了栈一章的痛苦煎熬后，终于迎来了串一章的柳暗花明。串，在概念上是比较少的一个章节，也是最容易自学的章节之一，但正如每个过来人所了解的，KMP算法是这一章的重要关隘，突破此关隘后，走过去又是一马平川的大好DS山河了，呵呵。串一章需要攻破的主要堡垒有：1.串的基本概念，串与线性表的关系（串是其元素均为字符型数据的特殊线性表），空串与空格串的区别，串相等的条件2.串的基本操作，以及这些基本函数的使用，包括：取子串，串连接，串替换，求串长等等。运用串的基本操作去完成特定的算法是很多学校在基本操作上的考查重点。3.顺序串与链串及块链串的区别和联系，实现方式。4.KMP算法思想。KMP中next数组以及nextval数组的求法。明确传统模式匹配算法的不足，明确next数组需要改进之外。其中，理解算法是核心，会求数组是得分点。不用我多说，这一节内容是本章的重中之重。可能进行的考查方式是：求next和nextval数组值，根据求得的next或nextval数组值给出运用KMP算法进行匹配的匹配过程。第四章 数组与广义表学过程序语言的朋友，数组的概念我们已经不是第一次见到了，应该已经“一回生，二回熟”了，所以，在概念上，不会存在太大障碍。但作为考研课程来说，本章的考查重点可能与大学里的程序语言所关注的不太一样，下面会作介绍。广义表的概念，是数据结构里第一次出现的。它是线性表或表元素的有限序列，构成该结构的每个子表或元素也是线性结构的，所以，这一章也归入线性结构中。本章的考查重点有：1.多维数组中某数组元素的position求解。一般是给出数组元素的首元素地址和每个元素占用的地址空间并组给出多维数组的维数，然后要求你求出该数组中的某个元素所在的位置。2.明确按行存储和按列存储的区别和联系，并能够按照这两种不同的存储方式求解1中类型的题。3.将特殊矩阵中的元素按相应的换算方式存入数组中。这些矩阵包括：对称矩阵，三角矩阵，具有某种特点的稀疏矩阵等。熟悉稀疏矩阵的三种不同存储方式：三元组，带辅助行向量的二元组，十字链表存储。掌握将稀疏矩阵的三元组或二元组向十字链表进行转换的算法。4.广义表的概念，特别应该明确表头与表尾的定义。这一点，是理解整个广义表一节算法的基础。近来，在一些学校中，出现了这样一种题目类型：给出对某个广义表L若干个求了若干次的取头和取尾操作后的串值，要求求出原广义表L。大家要留意。5.与广义表有关的递归算法。由于广义表的定义就是递归的，所以，与广义表有关的算法也常是递归形式的。比如：求表深度，复制广义表等。这种题目，可以根据不同角度广义表的表现形式运用两种不同的方式解答：一是把一个广义表看作是表头和表尾两部分，分别对表头和表尾进行操作；二是把一个广义表看作是若干个子表，分别对每个子表进行操作。第五章 树与二叉树从对线性结构的研究过度到对树形结构的研究，是数据结构课程学习的一次跃变，此次跃变完成的好坏，将直接关系到你到实际的考试中是否可以拿到高分，而这所有的一切，将最终影响你的专业课总分。所以，树这一章的重要性，已经不说自明了。总体来说，树一章的知识点包括：二叉树的概念、性质和存储结构，二叉树遍历的三种算法（递归与非递归），在三种基本遍历算法的基础上实现二叉树的其它算法，线索二叉树的概念和线索化算法以及线索化后的查找算法，最优二叉树的概念、构成和应用，树的概念和存储形式，树与森林的遍历算法及其与二叉树遍历算法的联系，树与森林和二叉树的转换。下面我们来看考试中对以上知识的主要考查方法：1.二叉树的概念、性质和存储结构考查方法可有：直接考查二叉树的定义，让你说明二叉树与普通双分支树的区别；考查满二叉树和完全二叉树的性质，普通二叉树的五个性质：第i层的最多结点数，深度为k的二叉树的最多结点数，n0=n2+1的性质，n个结点的完全二叉树的深度，顺序存储二叉树时孩子结点与父结点之间的换算关系（左为：2*i，右为：2*i+1）。二叉树的顺序存储和二叉链表存储的各自优缺点及适用场合，二叉树的三叉链表表示方法。2.二叉树的三种遍历算法这一知识点掌握的好坏，将直接关系到树一章的算法能否理解，进而关系到树一章的算法设计题能否顺利完成。二叉树的遍历算法有三种：先序，中序和后序。其划分的依据是视其每个算法中对根结点数据的访问顺序而定。不仅要熟练掌握三种遍历的递归算法，理解其执行的实际步骤，并且应该熟练掌握三种遍历的非递归算法。由于二叉树一章的很多算法，可以直接根据三种递归算法改造而来（比如：求叶子个数），所以，掌握了三种遍历的非递归算法后，对付诸如：“利用非递归算法求二叉树叶子个数”这样的题目就下笔如有神了。我会在另一篇系列文章（）里给出三种遍历的递归和非递归算法的背记版，到时请大家一定熟记。3.可在三种遍历算法的基础上改造完成的其它二叉树算法：求叶子个数，求二叉树结点总数，求度为1或度为2的结点总数，复制二叉树，建立二叉树，交换左右子树，查找值为n的某个指定结点，删除值为n的某个指定结点，诸如此类等等等等。如果你可以熟练掌握二叉树的递归和非递归遍历算法，那么解决以上问题就是小菜一碟了。4.线索二叉树：线索二叉树的引出，是为避免如二叉树遍历时的递归求解。众所周知，递归虽然形式上比较好理解，但是消耗了大量的内存资源，如果递归层次一多，势必带来资源耗尽的危险，为了避免此类情况，线索二叉树便堂而皇之地出现了。对于线索二叉树，应该掌握：线索化的实质，三种线索化的算法，线索化后二叉树的遍历算法，基本线索二叉树的其它算法问题（如：查找某一类线索二叉树中指定结点的前驱或后继结点就是一类常考题）。5.最优二叉树（哈夫曼树）：最优二叉树是为了解决特定问题引出的特殊二叉树结构，它的前提是给二叉树的每条边赋予了权值，这样形成的二叉树按权相加之和是最小的。最优二叉树一节，直接考查算法源码的很少，一般是给你一组数据，要求你建立基于这组数据的最优二叉树，并求出其最小权值之和，此类题目不难，属送分题。6.树与森林：二叉树是一种特殊的树，这种特殊不仅仅在于其分支最多为2以及其它特征，一个最重要的特殊之处是在于：二叉树是有序的！即：二叉树的左右孩子是不可交换的，如果交换了就成了另外一棵二叉树，这样交换之后的二叉树与原二叉树我们认为是不相同的两棵二叉树。但是，对于普通的双分支树而言，不具有这种性质。树与森林的遍历，不像二叉树那样丰富，他们只有两种遍历算法：先根与后根（对于森林而言称作：先序与后序遍历）。在难度比较大的考试中，也有基于此二种算法的基础上再进行扩展要求你利用这两种算法设计其它算法的，但一般院校很少有这种考法，最多只是要求你根据先根或后根写出他们的遍历序列。此二者的先根与后根遍历与二叉树中的遍历算法是有对应关系的：先根遍历对应二叉树的先序遍历，而后根遍历对应二叉树的中序遍历。这一点成为很多学校的考点，考查的方式不一而足，有的直接考此句话，有的是先让你求解遍历序列然后回答这个问题。二叉树、树与森林之所以能有以上的对应关系，全拜二叉链表所赐。二叉树使用二叉链表分别存放他的左右孩子，树利用二叉链表存储孩子及兄弟（称孩子兄弟链表），而森林也是利用二叉链表存储孩子及兄弟。树一章，处处是重点，道道是考题，大家务必个个过关。第六章 图如果说，从线性结构向树形结构研究的转变，是数据结构学科对数据组织形式研究的一次升华，那么从树形结构的研究转到图形结构的研究，则进一步让我们看到了数据结构对于解决实际问题的重大推动作用。图这一章的特点是：概念繁多，与离散数学中图的概念联系紧密，算法复杂，极易被考到，且容易出大题，尤其是名校，作为考研课程，如果不考查树与图两章的知识，几乎是不可想像的。下面我们看一下图这一章的主要考点以及这些考点的考查方式：1.考查有关图的基本概念问题：这些概念是进行图一章学习的基础，这一章的概念包括：图的定义和特点，无向图，有向图，入度，出度，完全图，生成子图，路径长度，回路，（强）连通图，（强）连通分量等概念。与这些概念相联系的相关计算题也应该掌握。2.考查图的几种存储形式：图的存储形式包括：邻接矩阵，（逆）邻接表，十字链表及邻接多重表。在考查时，有的学校是给出一种存储形式，要求考生用算法或手写出与给定的结构相对应的该图的另一种存储形式。3.考查图的两种遍历算法：深度遍历和广度遍历深度遍历和广度遍历是图的两种基本的遍历算法，这两个算法对图一章的重要性等同于“先序、中序、后序遍历”对于二叉树一章的重要性。在考查时，图一章的算法设计题常常是基于这两种基本的遍历算法而设计的，比如：“求最长的最短路径问题”和“判断两顶点间是否存在长为K的简单路径问题”，就分别用到了广度遍历和深度遍历算法。4.生成树、最小生成树的概念以及最小生成树的构造：PRIM算法和KRUSKAL算法。考查时，一般不要求写出算法源码，而是要求根据这两种最小生成树的算法思想写出其构造过程及最终生成的最小生成树。5.拓扑排序问题：拓扑排序有两种方法，一是无前趋的顶点优先算法，二是无后继的顶点优先算法。换句话说，一种是“从前向后”的排序，一种是“从后向前”排。当然，后一种排序出来的结果是“逆拓扑有序”的。6.关键路径问题：这个问题是图一章的难点问题。理解关键路径的关键有三个方面：一是何谓关键路径，二是最早时间是什么意思、如何求，三是最晚时间是什么意思、如何求。简单地说，最早时间是通过“从前向后”的方法求的，而最晚时间是通过“从后向前”的方法求解的，并且，要想求最晚时间必须是在所有的最早时间都已经求出来之后才能进行。这个问题拿来直接考算法源码的不多，一般是要求按照书上的算法描述求解的过程和步骤。在实际设计关键路径的算法时，还应该注意以下这一点：采用邻接表的存储结构，求最早时间和最晚时间要采用不同的处理方法，即：在算法初始时，应该首先将所有顶点的最早时间全部置为0。关键路径问题是工程进度控制的重要方法，具有很强的实用性。7.最短路径问题：与关键路径问题并称为图一章的两只拦路虎。概念理解是比较容易的，关键是算法的理解。最短路径问题分为两种：一是求从某一点出发到其余各点的最短路径；二是求图中每一对顶点之间的最短路径。这个问题也具有非常实用的背景特色，一个典型的应该就是旅游景点及旅游路线的选择问题。解决第一个问题用DIJSKTRA算法，解决第二个问题用FLOYD算法。注意区分。第七章 查找在不少数据结构的教材中，是把查找与排序放入高级数据结构中的。应该说，查找和排序两章是前面我们所学的知识的综合运用，用到了树、也用到了链表等知识，对这些数据结构某一方面的运用就构成了查找和排序。现实生活中，search几乎无处不在，特别是现在的网络时代，万事离不开search，小到文档内文字的搜索，大到INTERNET上的搜索，search占据了我们上网的大部分时间。在复习这一章的知识时，你需要先弄清楚以下几个概念：关键字、主关键字、次关键字的含义；静态查找与动态查找的含义及区别；平均查找长度ASL的概念及在各种查找算法中的计算方法和计算结果，特别是一些典型结构的ASL值，应该记住。在DS的教材中，一般将search分为三类：1st，在顺序表上的查找；2nd，在树表上的查找；3rd，在哈希表上的查找。下面详细介绍其考查知识点及考查方式：1.线性表上的查找：主要分为三种线性结构：顺序表，有序顺序表，索引顺序表。对于第一种，我们采用传统查找方法，逐个比较。对于及有序顺序表我们采用二分查找法。对于第三种索引结构，我们采用索引查找算法。考生需要注意这三种表下的ASL值以及三种算法的实现。其中，二分查找还要特别注意适用条件以及其递归实现方法。2.树表上的查找：这是本章的重点和难点。由于这一节介绍的内容是使用树表进行的查找，所以很容易与树一间的某些概念相混淆。本节内容与树一章的内容有联系，但也有很多不同，应注意规纳。树表主要分为以下几种：二叉排序树，平衡二叉树，B树，键树。其中，尤以前两种结构为重，也有部分名校偏爱考B树的。由于二叉排序树与平衡二叉树是一种特殊的二叉树，所以与二叉树的联系就更为紧密，二叉树一章学好了，这里也就不难了。二叉排序树，简言之，就是“左小右大”，它的中序遍历结果是一个递增的有序序列。平衡二叉树是二叉排序树的优化，其本质也是一种二叉排序树，只不过，平衡二叉树对左右子树的深度有了限定：深度之差的绝对值不得大于1。对于二叉排序树，“判断某棵二叉树是否二叉排序树”这一算法经常被考到，可用递归，也可以用非递归。平衡二叉树的建立也是一个常考点，但该知识点归根结底还是关注的平衡二叉树的四种调整算法，所以应该掌握平衡二叉树的四种调整算法，调整的一个参照是：调整前后的中序遍历结果相同。B树是二叉排序树的进一步改进，也可以把B树理解为三叉、四叉....排序树。除B树的查找算法外，应该特别注意一下B树的插入和删除算法。因为这两种算法涉及到B树结点的分裂和合并，是一个难点。B树是报考名校的同学应该关注的焦点之一。键树也称字符树，特别适用于查找英文单词的场合。一般不要求能完整描述算法源码，多是根据算法思想建立键树及描述其大致查找过程。3.基本哈希表的查找算法：哈希一词，是外来词，译自“hash”一词，意为：散列或杂凑的意思。哈希表查找的基本思想是：根据当前待查找数据的特征，以记录关键字为自变量，设计一个function，该函数对关键字进行转换后，其解释结果为待查的地址。基于哈希表的考查点有：哈希函数的设计，冲突解决方法的选择及冲突处理过程的描述。第八章 内部排序内排是DS课程中最后一个重要的章节，建立在此章之上的考题可以有多种类型：填空，选择，判断乃至大型算法题。但是，归结到一点，就是考查你对书本上的各种排序算法及其思想以及其优缺点和性能指标（时间复杂度）能否了如指掌。这一章，我们对重点的规纳将跟以上各章不同。我们将从以下几个侧面来对排序一章进行不同的规纳，以期能更全面的理解排序一章的总体结构及各种算法。从排序算法的种类来分，本章主要阐述了以下几种排序方法：插入、选择、交换、归并、计数等五种排序方法。其中，在插入排序中又可分为：直接插入、折半插入、2路插入、希尔排序。这几种插入排序算法的最根本的不同点，说到底就是根据什么规则寻找新元素的插入点。直接插入是依次寻找，折半插入是折半寻找。希尔排序，是通过控制每次参与排序的数的总范围“由小到大”的增量来实现排序效率提高的目的。交换排序，又称冒泡排序，在交换排序的基础上改进又可以得到快速排序。快速排序的思想，一语以敝之：用中间数将待排数据组一分为二。快速排序，在处理的“问题规模”这个概念上，与希尔有点相反，快速排序，是先处理一个较大规模，然后逐渐把处理的规模降低，最终达到排序的目的。选择排序，相对于前面几种排序算法来说，难度大一点。具体来说，它可以分为：简单选择、树选择、堆排。这三种方法的不同点是，根据什么规则选取最小的数。简单选择，是通过简单的数组遍历方案确定最小数；树选择，是通过“锦标赛”类似的思想，让两数相比，不断淘汰较大（小）者，最终选出最小（大）数；而堆排序，是利用堆这种数据结构的性质，通过堆元素的删除、调整等一系列操作将最小数选出放在堆顶。堆排序中的堆建立、堆调整是重要考点。树选择排序，也曾经在一些学校中的大型算法题中出现，请大家注意。归并排序，故名思义，是通过“归并”这种操作完成排序的目的，既然是归并就必须是两者以上的数据集合才可能实现归并。所以，在归并排序中，关注最多的就是2路归并。算法思想比较简单，有一点，要铭记在心：归并排序是稳定排序。基数排序，是一种很特别的排序方法，也正是由于它的特殊，所以，基数排序就比较适合于一些特别的场合，比如扑克牌排序问题等。基数排序，又分为两种：多关键字的排序（扑克牌排序），链式排序（整数排序）。基数排序的核心思想也是利用“基数空间”这个概念将问题规模规范、变小，并且，在排序的过程中，只要按照基排的思想，是不用进行关键字比较的，这样得出的最终序列就是一个有序序列。本章各种排序算法的思想以及伪代码实现，及其时间复杂度都是必须掌握的，学习时要多注意规纳、总结、对比。此外，对于教材中的10.7节，要求必须熟记，在理解的基础上记忆，这一节几乎成为很多学校每年的必考点。至此，数据结构所有章节的章节重点问题，我们已经规纳完毕，使用清华严版教材的同学，在复习的同时，可以参照本贴给出的重点进行复习。但是，由于作者本人水平有限，可能有很多考点没有规纳出来，也可能有些考点规纳有误，在此，作者本人诚恳希望诸位朋友直面提出，我会不断完善和发布新的关于数据结构复习的总结以及笔记严蔚敏数据结构为主的笔记二第二章：线性表(包括习题与答案及要点)--------------------------------------------------------------------------------本章的重点是掌握顺序表和单链表上实现的各种基本算法及相关的时间性能分析，难点是使用本章所学的基本知识设计有效算法解决与线性表相关的应用问题。要求达到<识记>层次的内容有:线性表的逻辑结构特征；线性表上定义的基本运算，并利用基本运算构造出较复杂的运算。要求达到<综合应用>层次的内容有：顺序表的含义及特点，顺序表上的插入、删除操作及其平均时间性能分析，解决简单应用问题。链表如何表示线性表中元素之间的逻辑关系；单链表、双链表、循环链表链接方式上的区别；单链表上实现的建表、查找、插入和删除等基本算法及其时间复杂度。循环链表上尾指针取代头指针的作用，以及单循环链表上的算法与单链表上相应算法的异同点。双链表的定义和相关算法。利用链表设计算法解决简单应用问题。要求达到<领会>层次的内容就是顺序表和链表的比较，以及如何选择其一作为其存储结构才能取得较优的时空性能。--------------------------------------------------------------------------------线性表的逻辑结构特征是很容易理解的，如其名，它的逻辑结构特征就好象是一条线，上面打了一个个结，很形象的，如果这条线上面有结，那么它就是非空表，只能有一个开始结点，有且只能有一个终端结点，其它的结前后所相邻的也只能是一个结点(直接前趋和直接后继)。关于线性表上定义的基本运算，主要有构造空表、求表长、取结点、查找、插入、删除等。--------------------------------------------------------------------------------线性表的逻辑结构和存储结构之间的关系。在计算机中，如何把线性表的结点存放到存储单元中，就有许多方法，最简单的方法就是按顺序存储。就是按线性表的逻辑结构次序依次存放在一组地址连续的存储单元中。在存储单元中的各元素的物理位置和逻辑结构中各结点相邻关系是一致的。在顺序表中实现的基本运算主要讨论了插入和删除两种运算。相关的算法我们通过练习掌握。对于顺序表的插入和删除运算，其平均时间复杂度均为O(n)。--------------------------------------------------------------------------------线性表的链式存储结构。它与顺序表不同，链表是用一组任意的存储单元来存放线性表的结点，这组存储单元可以分布在内存中任何位置上。因此，链表中结点的逻辑次序和物理次序不一定相同。所以为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还存储了其后继结点的地址信息(即

指的是稀疏矩阵吧tu指的是稀疏矩阵中非零元素个数mu*nu当然指的是矩阵的行*列因此如果tu和mu*nu是同数量级，意思就是这个矩阵中的非零元素个数已经和矩阵中的总元素个数同数量级了，当然也就是说这个矩阵不是那么稀疏了

HBase采用了类似Google Bigtable的数据模型，即一个稀疏的、分布式的、持久化的多维映射表，每个表都由行键、列族、列限定符和时间戳组成。在底层实现上，HBase使用了基于Hadoop的分布式文件系统HDFS来存储数据，并且使用了一种称为LSM-Tree（Log-Structured Merge-Tree）的数据结构来管理数据。LSM-Tree是一种支持高写入吞吐量的数据结构，它把数据分成多个层，每层采用不同的策略来管理数据，包括内存中的缓存、写入磁盘的SSTable、和合并SSTable的操作。通过这种方式，HBase能够支持高并发、高吞吐量的数据写入，同时保证数据的一致性和可靠性。另外，HBase还采用了Bloom Filter、MemStore和Compaction等技术来提高数据查询效率和存储效率。Bloom Filter是一种快速的数据过滤技术，可以帮助HBase快速地过滤掉无效的查询请求，提高查询效率。MemStore是一种缓存机制，可以帮助HBase加速数据写入，提高数据写入效率。Compaction则是一种数据压缩和合并技术，可以帮助HBase节省存储空间，提高存储效率。综上所述，HBase采用了LSM-Tree、Bloom Filter、MemStore和Compaction等多种数据结构和技术，以实现高并发、高吞吐量的分布式存储和查询功能。

1.c 2.c. 3.c 4.c 5.a 6.a 7.b 8.b 9.b 10.b11.a 12.b 13.b 14.b 15.b 16.a 17.c 18. d 19.c 20.d 21.b 22.c 23.b

你可以先放1，然后把1拿出来，或者放1234，把4拿出来之后，再放56，那顺序就是465321了

http://wenku.baidu.com/view/19ab8a80bceb19e8b8f6ba81.html 自己看。百度文库有答案

你没有说明tag用于什么地方啊，这个含义就不明确的。

先看一下hash表的结构图： 哈希表（Hash table，也叫散列表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表 白话一点的说就是通过把Key通过一个固定的算法函数（hash函数）转换成一个整型数字，然后就对该数字对数组的长度进行取余，取余结果就当作数组的下标，将value存储在以该数字为下标的数组空间里。 先了解一下下面几个常说的几个关键字是什么： key ：我们输入待查找的值 value ：我们想要获取的内容 hash值 ：key通过hash函数算出的值（对数组长度取模，便可得到数组下标） hash函数（散列函数） ：存在一种函数F，根据这个函数和查找关键字key，可以直接确定查找值所在位置，而不需要一个个遍历比较。这样就预先知道key在的位置，直接找到数据，提升效率。 即 地址index=F(key) hash函数就是根据key计算出该存储地址的位置，hash表就是基于hash函数建立的一种查找表。 方法有很多种，比如直接定址法、数字分析法、平方取中法、折叠法、随机数法、除留余数法等，网上相关介绍有很多，这里就不重点说这个了 对不同的关键字可能得到同一散列地址， 即k1≠k2，而f(k1)=f(k2)，或f(k1) MOD 容量 =f(k2) MOD 容量 ，这种现象称为 碰撞 ，亦称 冲突 。 通过构造性能良好的hash函数，可以减少冲突，但一般不可能完全避免冲突，因此解决冲突是hash表的另一个关键问题。 创建和查找hash表都会遇到冲突，两种情况下解决冲突的方法应该一致。 这里要提到两个参数： 初始容量 ， 加载因子 ，这两个参数是影响hash表性能的重要参数。 容量 ： 表示hash表中数组的长度，初始容量是创建hash表时的容量。 加载因子 ： 是hash表在其容量自动增加之前可以达到多满的一种尺度（存储元素的个数），它衡量的是一个散列表的空间的使用程度。 loadFactor = 加载因子 / 容量 一般情况下，当loadFactor <= 1时，hash表查找的期望复杂度为O(1). 对使用链表法的散列表来说， 负载因子越大，对空间的利用更充分，然后后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费 。系统默认负载因子为0.75。 当hash表中元素越来越多的时候，碰撞的几率也就越来越高（因为数组的长度是固定的），所以为了提高查询的效率，就要对数组进行扩容。而在数组扩容之后，最消耗性能的点就出现了，原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是 扩容 。 什么时候进行扩容呢？当表中 元素个数超过了容量 * loadFactor 时，就会进行数组扩容。 Foundation框架下提供了很多高级数据结构，很多都是和Core Foundation下的相对应，例如NSSet就是和_CFSet相对应，NSDictionary就是和_CFDictionary相对应。 源码 这里说的hash并不是之前说的hash表，而是一个方法。为什么要有hash方法？ 这个问题需要从hash表数据结构说起，首先看下如何在数组中查找某个成员 在数组未排序的情况下，查找的时间复杂度是O(n)（n为数组长度）。hash表的出现，提高了查找速度，当成员被加入到hash表中时，会计算出一个hash值，hash值对数组长度取模，会得到该成员在数组中的位置。 通过这个位置可以将查找的时间复杂度优化到O(1)，前提是在不发生冲突的情况下。 这里的hash值是通过hash方法计算出来的，且hash方法返回的hash值最好唯一 和数组相比，基于hash值索引的hash表查找某个成员的过程： 可以看出优势比较明显，最坏的情况和数组也相差无几。 重写person的hash方法和copyWithZone方法，方便查看hash方法是否被调用： 打印结果： 可以了解到： hash方法只在对象被添加到NSSet和设置为NSDictionary的key时被调用 NSSet添加新成员时，需要根据hash值来快速查找成员，以保证集合中是否已经存在该成员。 NSDictionary在查找key时，也是利用了key的hash值来提高查找的效率。 这里可以得到这个结论： 相等变量的hash结果总是相同的，不相等变量的hash结果有可能相同 根据数据结构可以发现set内部使用了指针数组来保存keys，可以从 源码 中了解到采用的是连续存储的方式存储。 NSSet添加key，key值会根据特定的hash函数算出hash值，然后存储数据的时候，会根据hash函数算出来的值，找到对应的下标，如果该下标下已有数据，开放定址法后移动插入，如果数组到达阈值，这个时候就会进行扩容，然后重新hash插入。查询速度就可以和连续性存储的数据一样接近O(1)了。 和上面的集合NSSet相比较，多了一个指针数组values。 通过比较集合NSSet和字典NSDictionary的 源码 可以知道两者实现的原理差不多，而字典则用了两个数组keys和values，说明这两个数据是被分开存储的。 通过源码可以看到，当有重复的key插入到字典NSDictionary时，会覆盖旧值，而集合NSSet则什么都不做，保证了里面的元素不会重复。 大家都知道，字典里的键值对key-value是一一对应的关系，从数据结构可以看出，key和value是分别存储在两个不同的数组里，这里面是如何对key、value进行绑定的呢？ 首先 key利用hash函数算出hash值，然后对数组的长度取模，得到数组下标的位置，同样将这个地址对应到values数组的下标，就匹配到相应的value。 注意到上面的这句话，要保证一点， 就是keys和values这两个数组的长度要一致 。所以扩容的时候，需要对keys和values两个数组一起扩容。 对于字典NSDictionary设置的key和value，key值会根据特定的hash函数算出hash值，keys和values同样多，利用hash值对数组长度取模，得到其对应的下标index，如果下标已有数据，开放定址法后移插入，如果数组达到阈值，就扩容，然后重新hash插入。这样的机制就把一些不连续的key-value值插入到能建立起关系的hash表中。 查找的时候，key根据hash函数以及数组长度，得到下标，然后根据下标直接访问hash表的keys和values，这样查询速度就可以和连续线性存储的数据一样接近O(1)了。 参考文章： 笔记-数据结构之 Hash（OC的粗略实现）

数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。数据的逻辑结构和储存结构是数据结构的两个密切相关的方面，同一逻辑结构可以对应不同的存储结构。算法的设计取决于数据的逻辑结构，而算法的实现依赖于指定的存储结构。数据结构的研究内容是构造复杂软件系统的基础，它的核心技术是分解与抽象。通过分解可以划分出数据的3个层次；再通过抽象，舍弃数据元素的具体内容，就得到逻辑结构。类似地，通过分解将处理要求划分成各种功能，再通过抽象舍弃实现细节，就得到运算的定义。数据的物理结构介绍：数据的物理结构是数据结构在计算机中的表示（又称映像），它包括数据元素的机内表示和关系的机内表示。由于具体实现的方法有顺序、链接、索引、散列等多种，所以，一种数据结构可表示成一种或多种存储结构。数据元素的机内表示（映像方法）：用二进制位（bit）的位串表示数据元素。通常称这种位串为节点（node）。当数据元素有若干个数据项组成时，位串中与各个数据项对应的子位串称为数据域（datafield）。因此，节点是数据元素的机内表示（或机内映像）。顺序存储结构和链式存储结构。顺序映像借助元素在存储器中的相对位置来表示数据元素之间的逻辑关系。非顺序映像借助指示元素存储位置的指针（pointer）来表示数据元素之间的逻辑关系。以上内容参考：百度百科-数据结构

B;标记耦合指两个模块之间传递的是数据结构,如高级语言的数组名,记录名,文件名等这些名字即为标记,其实传递的是这个数据结构的地址.

Draft.js 使用EditorState来保存数据结构顶层，其中记录了用于展示数据的所有数据结构。本文将通过提供一系列的简单示例来简单介绍 Draft.js 的数据结构。 Draft.js 基于 immutable.js 实现了一种不可变的数据结构，基于这种数据结构， Draft.js 实现了单项数据流，即 event -> onChange -> EditorState 我在 CodePen 上面实现了一个简单的Demo用于展示EditorState，你可以在上面尝试一下。 上图展示了一个完整的EditorState，我们可以轻易的猜测出一些属性的含义，比如currentContent记录了当前编辑器中展示内容的状态，selection中标识当前的选区，redoStack和undoStack分别是撤销、重做栈，而EditorState则提供了操作这些属性的顶层方法。 Draft 将样式分为块级样式与内联样式，块级样式之间线性排列，不可嵌套，内联样式则用数组记录，可以重叠。 当我在 draft 中随意输入一些文字的时候，text将会记录下文字内容，而此时用于记录块级样式的type值为 unstyled 现在我们将H1（块级元素）应用于文本，我们可以发现用于标识块级样式的type值变为了 header-one ，当我们继续在该行输入的时候，将会同样被赋予H1样式。通过上述的数据结构我们可以发现，由于块级样式由type所规定，所以块级样式之间不可被嵌套，即不会出现无序列表嵌套有序列表的情况出现。 对于同一块级元素中的文本内容， draft 将其按照字符进行拆分,每一个字符的内联样式用数组进行展示，由此可以解决内联样式的嵌套问题。 Entity并不是一个难以理解的数据类型，Entity数据主要用于展示一些不可被分割的数据类型，例如图片、mention、超链接等。 典型场景就是mention类型，详细来说，我们在日常使用中会在富文本编辑器中提及一些人， @xxx 的数据类型要求是一个统一整体，一旦 @xxx 中有某一个字符被删除，就有可能会出现 @ 出的名字和 @ 的对象不一致的情况。 在上图中，我将插入的图片数据结构打印了出来，我们可以发现这是一个Entity，记录了data，mutability与type， Draft.js 向外暴露了一个顶层接口，当Entity数据被注入的时候，可以通过这个接口来设计数据对象的展现方式，如下图

用数据库做，我觉得也很简单的。！

随便找本数据结构的书，应该就有，我看过，没记住

.........A..../.....|........B.....C.....D...|.......|.......|...E......F......G,虚线是定位用的，看实线。

MFC所有源代码都是公开的，在Visual Studio的src目录里，但是由于代码量很大，文件数量很多，所以你自己很难找到。如果只要看定义，h文件，那么直接在相应的类或者函数上面右键选择转到定义就可以看到，如果要看源代码，最好的办法是用调试。你写好代码比如CString str(_T("Test"));然后在这行设断点，然后调试，停在这行之后按F11单步进行，然后就就转到了CString类的构造函数了:CStringT( __in_z_opt const XCHAR* pszSrc ) : CThisSimpleString( StringTraits::GetDefaultManager() ) { if( !CheckImplicitLoad( pszSrc ) ) { // nDestLength is in XCHARs *this = pszSrc; } } 继续单步就可以进一步看到CheckImplicitLoad函数： bool CheckImplicitLoad( __in_opt const void* pv ) { bool bRet = false; if( (pv != NULL) && IS_INTRESOURCE( pv ) ) { UINT nID = LOWORD( reinterpret_cast< DWORD_PTR >( pv ) ); if( !LoadString( nID ) ) { ATLTRACE( atlTraceString, 2, _T( "Warning: implicit LoadString(%u) failed " ), nID ); } bRet = true; } return( bRet ); }

网上百度一下就行了。多的是。

冒择入希快归堆：冒泡、选择、插入、希尔、快速、归并、堆排序

不会。。。。。。。。。。。。。。。

ls那个推荐答案貌似没有解决楼主的提问啊

以我目前的水平只能回答你第三个问题。直接用G当然也可以，但是因为C语言按值传递，而G应该是一个挺大的结构体，将其复制一遍应当有较大开销；如果使用指针做参数，那么就省去了复制整个结构体的开销，而只用复制一个指针（相当于无符号整数）。按指针传递在很多情况下都被用来降低传值开销的。

我们的数据结构实验也是这题，需要我把我的实验报告给你参考下么！ 我这里就只发这部分的代码。Status PreOrderTraverse(BiTree T){ //先序遍历二叉树T的递归算法 if (T) { printf("%d ",T->data); if(T->lchild) PreOrderTraverse(T->lchild); if(T->rchild) PreOrderTraverse(T->rchild); return FALSE; } else return OK;}Status PreOrder(BiTree T){ //先序遍历二叉树T的非递归算法 while(!(T==NULL&&top==NULL)) { if(T) { printf("%d ",T->data); push(T); T=T->lchild; } else { T=(BiTree)pop(); T=T->rchild; } } }Status InOrderTraverse(BiTree T){ //中序遍历二叉树T的递归算法 if (T) { if (T->lchild) InOrderTraverse(T->lchild); printf("%d ",T->data); if (T->rchild) InOrderTraverse(T->rchild); return FALSE; } else return OK;}Status InOrder(BiTree T){ //中序遍历二叉树T的非递归算法 while(!(T==NULL&&top==NULL)) { while(T) { push(T); T=T->lchild; } T=(BiTree)pop(); printf("%d ",T->data); T=T->rchild; }}Status PostOrderTraverse(BiTree T){ //后序遍历二叉树T的递归算法 if (T) { if (T->lchild) PostOrderTraverse(T->lchild); if (T->rchild) PostOrderTraverse(T->rchild); printf("%d ",T->data); return FALSE; } else return OK;}Status PostOrder(BiTree T){ //后序遍历二叉树T的递归算法 unsigned sign;//记录结点从栈中弹出的次数 while(!(T==NULL&&top==NULL)) { if(T) { push(T);//第一次遇到结点T时压入其指针 push(1);//置标志为1 T=T->lchild; } else { while(top) { sign=pop(); T=(BiTree)pop(); if(1==sign)//表示走过T的左子树 { push(T); push(2); T=T->rchild; break; } else { if(2==sign)//表示T的左右子树都已走过 { printf("%d ",T->data); T=NULL; } } } } }}

比对着书上的写，书上不是有好几个例子吗，前序 中序 后序遍历 ，用递归或者普通方法都可以

如果有对gml格式转换成邻接表或邻接矩阵有问题的请看博文http://blog.sina.com.cn/s/blog_64914f1b0102vjzt.html或者http://weibo.com/p/1001603831291614203314

二叉树的基本操作 C语言实现/*程序实现内容1．采用二叉树链表作为存储结构，建立二叉树；2．对二叉树分别按先、中、后序以及按层次遍历，输出相应的访问序列；3．计算二叉树的深度，统计所有叶子结点总数及树中包含的结点总数。*/#include"stdio.h"#include"string.h"#include"malloc.h"#define Max 20 //结点的最大个数typedef struct node{char data;struct node *lchild,*rchild;}BinTNode; //自定义二叉树的结点类型typedef BinTNode *BinTree; //定义二叉树的指针int NodeNum,leaf; //NodeNum为结点数，leaf为叶子数//基于先序遍历算法创建二叉树//要求输入先序序列，其中加入虚结点“#”以示空指针的位置BinTree CreatBinTree(void){BinTree T;char ch;if((ch=getchar())=="#")return(NULL); //读入#，返回空指针else{T=(BinTNode *)malloc(sizeof(BinTNode));//生成结点T->data=ch;T->lchild=CreatBinTree(); //构造左子树T->rchild=CreatBinTree(); //构造右子树return(T);}}//DLR 先序遍历void Preorder(BinTree T){if(T) {printf("%c",T->data); //访问结点Preorder(T->lchild); //先序遍历左子树Preorder(T->rchild); //先序遍历右子树}}//LDR 中序遍历void Inorder(BinTree T){if(T) {Inorder(T->lchild); //中序遍历左子树printf("%c",T->data); //访问结点Inorder(T->rchild); //中序遍历右子树}}//LRD 后序遍历void Postorder(BinTree T){if(T) {Postorder(T->lchild); //后序遍历左子树Postorder(T->rchild); //后序遍历右子树printf("%c",T->data); //访问结点}}//采用后序遍历求二叉树的深度、结点数及叶子数的递归算法int TreeDepth(BinTree T){int hl,hr,max;if(T){hl=TreeDepth(T->lchild); //求左深度hr=TreeDepth(T->rchild); //求右深度max=hl>hr? hl:hr; //取左右深度的最大值NodeNum=NodeNum+1; //求结点数if(hl==0&&hr==0) leaf=leaf+1; //若左右深度为0，即为叶子。return(max+1);}else return(0);}//利用“先进先出”（FIFO）队列，按层次遍历二叉树void Levelorder(BinTree T){int front=0,rear=1;BinTNode *cq[Max],*p; //定义结点的指针数组cqcq[1]=T; //根入队while(front!=rear){front=(front+1)%NodeNum;p=cq[front]; //出队printf("%c",p->data); //出队，输出结点的值if(p->lchild!=NULL){rear=(rear+1)%NodeNum;cq[rear]=p->lchild; //左子树入队}if(p->rchild!=NULL){rear=(rear+1)%NodeNum;cq[rear]=p->rchild; //右子树入队}}}//主函数main(){BinTree root;int i,depth;printf(" ");printf("Creat Bin_Tree; Input preorder:"); //输入完全二叉树的先序序列，// 用#代表虚结点，如ABD###CE##F##root=CreatBinTree(); //创建二叉树，返回根结点do { //从菜单中选择遍历方式，输入序号。printf(" ********** select ************ ");printf(" 1: Preorder Traversal ");printf(" 2: Iorder Traversal ");printf(" 3: Postorder traversal ");printf(" 4: PostTreeDepth,Node number,Leaf number ");printf(" 5: Level Depth "); //按层次遍历之前，先选择4，求出该树的结点数。printf(" 0: Exit ");printf(" ******************************* ");scanf("%d",&i); //输入菜单序号（0-5）switch (i){case 1: printf("Print Bin_tree Preorder: ");Preorder(root); //先序遍历break;case 2: printf("Print Bin_Tree Inorder: ");Inorder(root); //中序遍历break;case 3: printf("Print Bin_Tree Postorder: ");Postorder(root); //后序遍历break;case 4: depth=TreeDepth(root); //求树的深度及叶子数printf("BinTree Depth=%d BinTree Node number=%d",depth,NodeNum);printf(" BinTree Leaf number=%d",leaf);break;case 5: printf("LevePrint Bin_Tree: ");Levelorder(root); //按层次遍历break;default: exit (1);}printf(" ");} while(i!=0);

我们正在上数据结构，已经写好了循环队列的所有算法代码。数组名你自己改一下啊，我没时间去改那个了。运行全部正确的。哦，忘了说明，我采用的语言是C++，编译环境是VC++ 6.0。其中包含三个文件：SqQueue.h SqQueue.cpp main.cpp至于那个怎么添加到VC中运行相信你知道吧，我就不说了。======================SqQueue.h=============================#include <iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2#define MAXQSIZE 100 //最大队列长度typedef int Status;typedef int QElemType;typedef struct{ QElemType * base; int front; int rear;}SqQueue;Status InitQueue(SqQueue & Q);int GetQueueLen(SqQueue Q);Status EnQueue(SqQueue & Q,QElemType e);Status DeQueue(SqQueue & Q,QElemType & e);Status QueueEmpty(SqQueue Q);Status GetHead(SqQueue Q,QElemType & e);Status ClearQueue(SqQueue & Q);Status DestoryQueue(SqQueue & Q);Status QueueTraverse(SqQueue Q);======================SqQueue.cpp=============================#include "SqQueue.h"Status InitQueue(SqQueue & Q){ Q.base = (QElemType *)malloc(MAXQSIZE*sizeof(QElemType)); if(!Q.base) exit(OVERFLOW); Q.front = Q.rear = 0; return OK;}int GetQueueLen(SqQueue Q){ return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;}Status EnQueue(SqQueue & Q,QElemType e){ if((Q.rear + 1)%MAXQSIZE == Q.front) //顺序队列已满 return ERROR; Q.base[Q.rear] = e; Q.rear = (Q.rear + 1)%MAXQSIZE; return OK;}Status DeQueue(SqQueue & Q,QElemType & e){ if(Q.rear == Q.front) //顺序队列空 return ERROR; e = Q.base[Q.front]; Q.front = (Q.front + 1)%MAXQSIZE; return OK;}Status QueueEmpty(SqQueue Q){ if(Q.rear == Q.front) return TRUE; return FALSE;}Status GetHead(SqQueue Q,QElemType & e){ if(Q.rear == Q.front) return ERROR; e = Q.base[Q.front]; return OK;}Status ClearQueue (SqQueue & Q){ Q.rear = Q.front; return OK;}Status DestoryQueue(SqQueue & Q){ free(Q.base); return OK;}Status QueueTraverse(SqQueue Q){ if(!Q.base) return ERROR; if(Q.rear == Q.front) return ERROR; int i = Q.front; while(i != Q.rear) { cout<<Q.base[i]<<" "; i++; } return OK;}======================main.cpp=============================#include "SqQueue.h"int main(){ Status status; SqQueue Q; int n; QElemType e; InitQueue(Q); cout<<"您想在队列中创建多少个元素？ n = "; cin>>n; for(int i = 0;i < n;i++) { cout<<" 请输入元素的值: "; cin>>e; EnQueue(Q,e); } status = QueueEmpty(Q); if(status) cout<<" 循环队列为空! "; else cout<<" 循环队列非空! "; status = DeQueue(Q,e); if(status) cout<<"被删除的队首元素是: "<<e<<endl<<endl; else cout<<"队首元素删除失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; cout<<"请输入您想向队列中插入的数值... e = "; cin>>e; status = EnQueue(Q,e); if(status) cout<<"插入成功! "; else cout<<"插入失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; status = GetHead(Q,e); if(status) cout<<"队首元素是: "<<e<<endl<<endl; else cout<<"ERROR! 获取队首元素失败! "; status = ClearQueue(Q); if(status) cout<<"循环队列清除成功! "; else cout<<"循环队列清除失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; status = DestoryQueue(Q); if(status) cout<<"循环队列销毁成功! "; else cout<<"循环队列销毁失败! "; n = GetQueueLen(Q); cout<<"队列的长度为: "<<n<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; return 0; /* QElemType e; int n; int i; int len; Status status; SqQueue Q; status = InitQueue(Q); if(status) cout<<"初始化成功! "<<endl; else cout<<"初始化失败! "<<endl; status = QueueEmpty(Q); if(status) cout<<"循环队列为空! "; else cout<<"循环队列非空! "; cout<<"您想为队列输入多少个元素？ 请输入:"; cin>>n; cout<<endl; for(i = 0;i<n;i++) { cout<<"请输入您想插入队列的元素值(后插):"; cin>>e; EnQueue(Q,e); } len = GetQueueLen(Q); cout<<" 队列长度为: "<<len<<endl<<endl; status = QueueEmpty(Q); if(status) cout<<"链性队列为空! "; else cout<<"链性队列非空! "; status = QueueTraverse(Q); if(status) cout<<" 遍历成功! "; else cout<<" 遍历失败! "; status = DeQueue(Q,e); if(status) { cout<<" 在队列中被删除的队首元素值是: "<<e; cout<<" 删除成功! "; } else cout<<" 删除失败! "; len = GetQueueLen(Q); cout<<"队列长度为: "<<len<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<" 遍历成功! "; else cout<<" 遍历失败! "; status = GetHead(Q,e); if(status) cout<<" 队列的队首元素是: "<<e<<endl; else cout<<" 获取队首元素失败! "; status = ClearQueue(Q); if(status) cout<<" 队列清除成功! "; else cout<<" 队列清除失败! "; len = GetQueueLen(Q); cout<<"队列长度为: "<<len<<endl<<endl; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; status = DestoryQueue(Q); if(status) cout<<" 队列销毁成功! "; else cout<<" 销毁失败! "; status = QueueTraverse(Q); if(status) cout<<"遍历成功! "; else cout<<"遍历失败! "; */}