千言万语ROOM

二叉排序树（二叉查找树）的定义：二叉排序树或者是一棵空树，或者是一棵具有以下性质的二叉树：（1）若它的左子树不为空，则左子树上所有结点的值均小于根结点的值；（2）若它的又子树 不为空，则右子树上所有结点的值均大于根结点的值；（3）它的左、右子树都是二叉排序树。二叉排序树的定义是递归的。由此可得到二叉排序树的一个重要性质：中序遍历一棵二叉排序树可得到有序递增序列。二叉排序树结点数据结构的定义（包括关键字项和其他数据项）：//每个结点数据域的数据类型 typedef struct

折半查找要求表中数据是有序的。折半查找的循环条件是low<=high而不是low<high，为low=high时，查找区间还有最后 一 个结点， 还要进 一 步比较。//折半查找 int SearchBin(SqList &L, int key){ int low=1; int high=L.length; while(low<=high){ int mid=(low+high)/2; if(key==L.elem[mid]){ return mid

广度优先搜索过程：（1）从图中的某和顶点v出发，访问v。（2）依次访问v的各个未曾访问过的邻接点。（3）从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问。重复步骤（3），直到图中所有已被访问的顶点的邻接点都被访问到。算法步骤：（1）从图中某个顶点v出发，访问v；置visited[v]为true，v入队；（2）只要队列非空，重复下述操作：第一：队头顶点u出队；第二：一次检查u的所有邻接点w，如果visited[w]=fal

广度优先搜索过程：（1）从图中的某和顶点v出发，访问v。（2）依次访问v的各个未曾访问过的邻接点。（3）从这些邻接点出发依次访问它们的邻接点，并使“先被访问的顶点的邻接点”先于“后被访问的顶点的邻接点”被访问。重复步骤（3），直到图中所有已被访问的顶点的邻接点都被访问到。算法步骤：（1）从图中某个顶点v出发，访问v；置visited[v]为true，v入队；（2）只要队列非空，重复下述操作：第一：队头顶点u出队；第二：一次检查u的所有邻接点w，如果visited[w]=fal

图的深度优先搜索的过程：(1)从图的某个顶点V出发，访问V.(2)找出刚访问过的顶点的第一个未被访问的邻接点，访问该顶点。以该顶点为新顶点，重复此步骤，直到刚顶点没有未bedi被访问的邻接点为止。（3）返回前一个访问过的且仍有未被访问的邻接点的顶点，找出该din顶点的下一个未被访问的邻接点，访问该顶点。(4)重复步骤（2）和（3），直到图中所有的顶点都被访问过，搜索结束。例如，上图的深度遍历过程如下：（1）从a顶点出发，访问a。（2）从a出发，访问第一个未被访问的邻接

图的邻接表表示法：邻接表(Adjacency List) 是图的 一 种链式存储结构。在邻接表中，对图中每个顶点V建立一个单链表，把与 V相邻接的顶点放在这个链表中。邻接表中每个单链表的第一个结点存放有关顶点的信息， 把这 一 结点看成链表的表头， 其余结点存放有关边的信息， 这样邻接表便由两部分组成：表头结点表和边表。(1) 表头结点表：由所有表头结点以顺序结构的形式存储， 以便可以随机访问任 一 顶点的边链表。表头结点包括数据域 (data) 和链域 (firstarc) 两部分。其中， 数据域

#include<stdio.h>#include<stack> #include <iostream>#define MAXSIZE 100#define MaxInt 32767 //表示最大值，即正无穷大 #define MVNum 100 //定义最大顶点数 using namespace std;typedef char VerTexType;//假设顶点数据类型为字符型typedef int ArcType;//假设边的权值为整型type.

带权路径最小的二叉树称为哈弗曼树。哈弗曼树是一棵二叉树。由于哈弗曼树中没有度为1的结点，所以有n个叶子结点的哈弗曼树有2n-1个结点，可以存储在大小为2n-1的一维数组中。每个结点要包含结点的权重、双亲结点的信息、孩子结点的信息。wight parent lchild rchild 哈弗曼树的结点形...

#include<stdio.h>#include<stack> #define MAXSIZE 100using namespace std;int count1=0;int count2=0;typedef struct BiNode{ char data;//数据域 struct BiNode *lchild, *rchild;//左右子树指针 }BiTNode, *BiTree;//先序遍历创建二叉链,输入：ABC##DE#G##F### (#表.

#include<stdio.h>#include<stack> #define MAXSIZE 100using namespace std;//---------二叉树的二叉链存储表示---------- typedef struct BiTNode{ char data;//节点数据域 struct BiTNode *lchild, *rchild;//左右孩子指针 }BiTNode, *BiTree;//----------------------.

思想：定义一个指针p，使其指向链表的首原结点，在递归过程中p不断指向后继结点，指导p为空结束递归。算法步骤：1.如果p为null，递归结束返回；2.否则输出p->data，p指向后继jied结点继续递归。#include<stdio.h>typedef struct LNode{ int data; struct LNode *next;}L...

单循环链表的合并设两个单循环链表A和B（都带头结点，设A和B都非空），合并A和B的思路是:将A最后一个结点的指针域指向B的第一个结点（即指向头结点后的那个结点），然后将B的最后一个元素的指针域指向A的头结点。（按该思路合并后，没有释放B的头结点）。算法：1.获取A的最后一个结点,设为p1;2.获取B的最后一个结点,设为p2;3.令p1的指针域指向B的第一个结点，p1->ne

/*设计一个算法，将带头结点的单链表A分解成两个结构相同的单链表B和C使得B中的元素是A中大于等于0的元素，C中的元素是A中小于0的元素。要求存储空间仍使用A的存储空间。 */#includetypedef struct LNode{ int data; struct LNode *next;}LNode,*LinkList;/*初始化单链表 */int InitLi

根据输入的栈的编号的不同，操作双栈中的其中一个：/*两个栈的编号分别为0和1，按照输入的栈号不同，操作不同的栈。假设数组左侧的栈编号为0；右端的栈编号为1. */ #include//定义双栈结构typedef struct{ int top[2],bot[2];//栈顶指针和栈底指针 int *V;//存储双栈的数组空间 int m;//数组空间的大小 }DblStac

题目描述：/*题目描述：将编号0和1的两个栈存放于一个空间V[m]的数组空间中，栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]=-1时该栈为空；当第1号栈的栈顶指针top[1]=m时，该栈为空。两个栈均从两端向中间增长。试编写双栈初始化，判断栈空，栈满，进栈，出栈等算法的函数。双栈结构的定义如下：typedef struct{int top[2],bot[2]

/*队列的链式表示和实现 (带头结点的链式队列)*/#include//定义 typedef struct QNode{ int data; struct QNode *next;}QNode,*QueuePtr;typedef struct{ QueuePtr front; QueuePtr rear;}LinkQueue;/*初始化：算法思想：生成一个头结点，

2.10 设计一个算法，删除顺序表中值为item的元素，要求算法的时间复杂度是O(n),空间复杂度是O(1)算法思想：设置两个指针，分别而从表的头和尾开始遍历，当遇到值为item的元素时，将右端 的uansu和左端的元素值交换。void Delete(List &L,int &item){ int i=1,j=L.length; while(i<j){ while(i<j&&L

2.3求两个递增链表的交集题目描述：已知两个链表A和B，分别表示两个集合，A和B的元素是递增的。设计一个算法求两个集合的交集，要求使用原来的存储空间。算法思路描述：/*算法思想：假设两个表分别是L1和L2，表的元素递增排列；需要3个指针，pa，pb，pc.指针的初始值是pa指向L1的第一个结点，pb指向L2的第一个结点，pc指向新表L3的头结点；初始时，L3指向

2.9 交换双向循环链表的结点p和它的前驱结点  题目描述：已知p指向双向循环链表中的一个结点，其结点结构为data,prior,next三个域；写出算法change(p),交换p所指向的结点及其前驱结点的顺序。交换算法：void Change(LinkList p){ struct DLnode *q; q=p->prior; q->prior->next=

单链表的合并一般单链表的合并和前一篇博客写的但循环链表的合并思路基本一致，区别在于合并后不用将最后一个结点的指针域指向头结点。//合并void Combine(LinkList L1,LinkList L2){ struct LNode *p1; struct LNode *p2; p1=L1->next; p2=L2->next; struct LNode *s1,*s2;

2.1递增链表的合并题目描述：设计一个算法将两个递增链表合并成一个递增链表，仍使用原来的存储空间，不申请新的存储空间，且新表中不能有重复元素。 假设要合并的两个链表的元素都是一次递增的。算法思想：设立三个指针pa,pb,pc,其中pa，pb执行LA,和LB中待比较的结点，而pc执行LC表当前最后一个结点。pa,pb,pc的初始值为：pa,pb指向LA和LB的第一

/*设计一个算法，通过一趟遍历，找出链表中的最大元素。 */ #includetypedef struct LNode{ int data; struct LNode *next;}LNode,*LinkList;int InitList(LinkList &L){ L=new LNode; L->next=NULL; return 1;}void CreateL

/*算法思想：1.当字符串的长度是偶数时，入栈的字符个数正好是整个字符串的一半；则在栈非空的情况下，依次将栈顶元素出栈，并和字符串后半段的元素比较，当栈顶元素和当前字符串不相同，说明不是回文串，返回false；反之，将新的栈顶元素和下一个字符比较，直到栈为空时，说明是回文串。 2.当字符串的长度是奇数时，需要将中间的字符跳过；入栈的是中间字符前面的字符，并将栈中的元素和中间字符后面

首先最简单的是实现10进制和2进制的转换/*输入一个数，然后输出其对应的8进制的数 */ #include#define MAX 1000//顺序栈存储空间最大值 //int n,m;//n表示输入的数，m表示输出的数的进制 //先定义一个顺序栈的结构typedef struct{ int *base;//栈底4指针 int *top;//栈顶指针 int stack

愚人节的礼物Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 5186    Accepted Submission(s): 3160Problem Description四月一日快到了，Vayko想了个愚人的好办法—

输入节点值得时候要注意!!!要按照abc##de#g##f###的格式输入。/*二叉树 */#include//使用二叉链表存储二叉树 typedef struct BiTNode{ char data; struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;//先序遍历的顺序简历二叉链表 void CreateBiTree

需要注意的地方：1.文件的路径格式，在DevC++中，char *filePath="F://result.txt";FILE *fp;while((fp=fopen(filePath,"w"))==NULL){printf("文件无法打开.\n");exit(0);}打开文件的路径是"F://result.txt",而不是"F:\result.txt",注意“

题目描述:假设以I和O分别表示入栈和出栈操作，栈的初试状态和终态都是空，出栈和入栈序列仅有I和O组成。称可以操作的序列为合法序列，否则为非法序列。写一个算法判断一个给定的序列是否合法。若合法返回True，否则返回false.题目分析：一个由出栈操作和入栈操作组成的序列，要是合法序列应该满足：1.入栈的操作次数大于等于出栈操作的次数；2.当遇到每个出栈操作时，判断

#includevoid Conversion(int n){ if(n==0){ //printf("%d",0); return; }else{ Conversion(n/2); printf("%d",n%2); }}int main(){ int n; printf("请输入一个数:"); scanf("%d",&n); Conversion(n);}

题目描述：用带头结点的循环链表表示队列，并设置一个尾指针指向队尾元素。不设置投指针。编写置队空，判断队空，出队，入队等算法， /*链队结构定义 *///定义节点类型 typedef struct QNode{ int data;//数据域 struct QNode *next;//指针域 }QNode,*QueuePtr;//只设置一个尾指针

/*队列的链式表示 */#include/*定义链式队列的存储结构 */ typedef struct QNode{ int data; struct QNode *next;}QNode,*QueuePtr;typedef struct{ QueuePtr front; QueuePtr rear;}LinkQueue;/*初始化链式队列 思想:构造一个

/*队列的线性表示--循环队列 */ #include#define MAXQSIZE 100/*定义顺序队列 */typedef struct{ int *base;//分配存储空间 int front;//队头指针 int rear;//队尾指针 }SqQueue;//初始化循环队列 /*算法思想：循环队列的初始化就是动态分配一个预定义大小的数组空间，b

使用数组实现10进制向任何进制数制的转换。算法思想：使用数组模拟栈，将n%m加到数组中，然后将数组的元素倒叙输出即可。#includeint stack[100];int n,m;//n表示要转换的数，m表示进制//初始化数组int Init(int stack[]){ for(int i=0;i<100;i++){ stack[i]=-1; } return 1;

使用栈实现10进制的数向任何进制的数转换。

单循环链表循环链表的特点是最后一个元素的指针域指向头结点。因此对于循环链表的初始化（设表的头结点是L， 不再是L->next=NULL，而是L->next=L。循环链表为空时，头结点的下一个结点依然是头结点本身。因此但虚幻链表的初始化如下：（数据类型设为int）//初始化 int InitList(LinkList &L){ L=new LNode; L->nex

#include#includeusing namespace std;#define MAX 100typedef struct STU{ char name[20]; char sno[20]; int age; float score;}Student;typedef struct LNode{ Student data; struct LNode *next;

将一个带头结点的单链表分解成两个单链表题目描述：/*设计一个算法，将一个带头结点的单链表分解成两个具有相同结构的链表B和C，其中B白哦的结点为A中小于0的结点，C表的结点为A中大于0 的结点，要求B和C 仍利用A表的结点。 (A表的元素都是非0元素)*/算法思想：‘假设原来的连败哦是LA，将La，分解成LB和LC，首先需要生成两个头结点，LB和LC；设置

郁闷的C小加（一）时间限制：1000 ms  |  内存限制：65535 KB难度：3描述我们熟悉的表达式如a+b、a+b*(c+d)等都属于中缀表达式。中缀表达式就是（对于双目运算符来说）操作符在两个操作数中间：num1 operand num2。同理，后缀表达式就是操作符在两个操作数之后：num1 num2 operand。ACM队的“C小加”正在郁闷怎样把一个中缀表达

中缀式变后缀式时间限制：1000 ms  |  内存限制：65535 KB难度：3描述人们的日常习惯是把算术表达式写成中缀式，但对于机器来说更“习惯于”后缀式，关于算术表达式的中缀式和后缀式的论述一般的数据结构书都有相关内容可供参看，这里不再赘述，现在你的任务是将中缀式变为后缀式。输入第一行输入一个整数n，共有n组测试数据（n每组测试数据只有一行，是

汉诺塔（三）时间限制：3000 ms  |  内存限制：65535 KB难度：3描述在印度，有这么一个古老的传说：在世界中心贝拿勒斯（在印度北部）的圣庙里，一块黄铜板上插着三根宝石针。印度教的主神梵天在创造世界的时候，在其中一根针上从下到上地穿好了由大到小的64片金片，这就是所谓的汉诺塔。不论白天黑夜，总有一个僧侣在按照下面的法则移动这些金片：一次只移动一片