cls算法

㈠ 二叉树中序遍历递归算法

if(T){
if(InOrderTraverse(T->l,Visit))
if(Visit(T->data))
if(InOrderTraverse(T->r,Visit)) return OK;
return ERROR;
}else return OK;
以上就是中序遍历二叉树
这段程序我全有，具体如下：
#include <alloc.h>

#define ERROR 0;
#define FALSE 0;
#define TRUE 1;
#define OK 1;

typedef int ElemType;
typedef int Status;
typedef int KeyType;

#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)< (b))
#define LQ(a,b) ((a)<=(b))

typedef struct BinaryTree //定义二叉树
{
ElemType data;
struct BinaryTree *l;
struct BinaryTree *r;
}*BiTree,BiNode;//

BiNode * new()//为新结点开辟空间
{
return( (BiNode *)malloc(sizeof(BiNode)) );
}

CreateSubTree(BiTree *T,ElemType *all,int i)//创建新有子树
{
if ((all[i]==0)||i>16)
{
*T=NULL;
return OK;
}
*T=new();
if(*T==NULL) return ERROR;
(*T)->data=all[i];
CreateSubTree(&((*T)->l),all,2*i);
CreateSubTree(&((*T)->r),all,2*i+1);
}

CreateBiTree(BiTree *T)//创建新结点
{
ElemType all[16]={0,1,2,3,0,0,4,5,0,0,0,0,6,0,0,0,};
CreateSubTree(T,all,1);
}

printelem(ElemType d)//输出
{
printf("%d\n",d);
}

PreOrderTraverse(BiTree T,int (*Visit)(ElemType d))//前序遍历
{
if(T){
if(Visit(T->data))
if(PreOrderTraverse(T->l,Visit))
if(PreOrderTraverse(T->r,Visit)) return OK;
return ERROR;
} else return OK;
}

InOrderTraverse(BiTree T,int (*Visit)(ElemType d))//中序遍历
{
if(T){
if(InOrderTraverse(T->l,Visit))
if(Visit(T->data))
if(InOrderTraverse(T->r,Visit)) return OK;
return ERROR;
}else return OK;
}

Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree *p){

if(!T) {*p=f;return FALSE;}
else if EQ(key,T->data){ *p=T;return TRUE;}
else if LT(key,T->data) SearchBST(T->l,key,T,p);
else SearchBST(T->r,key,T,p);
}

Status InsertBST(BiTree *T,ElemType e){
BiTree p;
BiTree s;
if(!SearchBST(*T,e,NULL,&p)){
s=(BiTree)malloc(sizeof(BiNode));
s->data=e;s->l=s->r=NULL;
if(!p) *T=s;
else if (LT(e,p->data)) p->l=s;
else p->r=s;
return TRUE;
}
else return FALSE;
}

void Delete(BiTree *p){
BiTree q,s;
if(!(*p)->r){
q=(*p);
(*p)=(*p)->l;
free(q);
}
else if(!(*p)->l){
q=(*p);
(*p)=(*p)->r;
free(q);
}
else {

/* q=(*p);
s=(*p)->l;
while(s->r) {q=s; s=s->r;}
(*p)->data=s->data;
if(q!=(*p) ) q->r=s->l;
else q->l=s->l;
free(s);
*/

q=s=(*p)->l;
while(s->r) s=s->r;
s->r=(*p)->r;
free(*p);
(*p)=q;

}
}

Status DeleteBST(BiTree *T,KeyType key){
if (!(*T) )
{return FALSE;}
else{
if ( EQ(key,(*T)->data)) Delete(T);
else if ( LT(key,(*T)->data)) DeleteBST( &((*T)->l), key);
else DeleteBST( &((*T)->r),key);
return TRUE;
}
}

main()
{
BiTree root;
BiTree sroot=NULL;
int i;
int a[10]={45,23,12,3,33, 27,56,90,120,62};
system("cls");
CreateBiTree(&root);
printf("PreOrderTraverse:\n");
PreOrderTraverse(root,printelem);
printf("InOrderTraverse:\n");
InOrderTraverse(root,printelem);
for(i=0;i<10;i++)
InsertBST(&sroot,a[i]);
printf("InOrderTraverse:\n");
InOrderTraverse(sroot,printelem);
for(i=0;i<3;i++)
DeleteBST(&sroot,a[i]);
printf("Now sroot has nodes:\n");
InOrderTraverse(sroot,printelem);
}

㈡ 坐标算法

你运行一下，看是不是这个效果。
#include <stdio.h>
main()
{
int i,n,m;
system("cls") ;
for (i=10;i<16;i++)
{
n=(i+2)/5*5;
printf("i=%d\tn=%d\n",i,n);
}
getch();
}

㈢ C语言求所有四阶幻方

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

#define EVEN_DOUBLE_4 4 //双偶的最基本类型，4阶双偶
#define SCREEN_SIZE 19 //屏幕显示不变形的最大尺寸（主要是因为窗口大小限制）
#define MIN_SIZE 3 //最小阶数为3
#define MAX_SIZE 30
/*原则上是任意阶，算法是相同的，这里就以30为上限吧，
当然如果你愿意，可以修改的更大一些*/

#define PRINT printf("Esc退出，Enter继续"); //打印的宏
#define CLEAR row = 0; column = 0; //清零

int Magic[MAX_SIZE][MAX_SIZE]={0}; //全局，幻方数组
int row = 0; column = 0; //全局，幻方的行列数

int main(void)
{
int read(); //读取函数
void odd(int size, int ini_value ); //奇数阶幻方生成
void mean_double_4(int size); //4阶双偶生成
void mean_double(int size); //双偶生成
void mean_single(int size); //单偶生成
void print_magic(int size); //打印幻方
void sum_print(int data[], int size); //行、列、对之和打印
void clear_sum(int data[]);
void check_magic(int data[], int size ); //检查所得矩阵是否为幻方阵

int size; //幻方阶数
int sum[2*MAX_SIZE+2] = {0};//行、列、对之和

do{
CLEAR
clear_sum(sum);
size=read();
system("cls");

if(size%2 != 0 ) odd(size, 0);
else if(size %4 == 0) mean_double(size);
else mean_single(size);

print_magic(size);
sum_print(sum, size);
check_magic(sum,size);
PRINT

}while (getch() != 27);

return 0;
}

/*读入数据*/
int read()
{
int min_size = MIN_SIZE;
int max_size = MAX_SIZE;
int size;

do{
printf("请输入幻方阶数n，n∈[%d,%d]\n", min_size, max_size);
scanf("%d", &size);
getchar();
if(size<3 || size > MAX_SIZE) printf("非法输入，请重新输入[%d,%d]的正整数\n", min_size, max_size);
else if(size > SCREEN_SIZE){
printf("大于屏显最大阶数，输出将变形\n");
Sleep(2000);
}
}while(size < MIN_SIZE || size > MAX_SIZE);

return size;
}

/*奇数阶幻方，采用house法*/
void odd(int size, int ini_value)
{
int num; //填充数字
int min_num = 1+ini_value;
int max_num = 1+size*size+ini_value; //填充范围
int x = size/2;
int y = 0; //初始填充坐标

for(num = min_num; num < max_num; num++){
Magic[y+row][x+column] = num;
if(num % size == 0) y++; //跳步
else x++, y += 2; //马步，其实Horse法和Siamese是完全类似的
x = x % size ;
y = y % size ;
/*越界反弹，即触碰到边界，从另一边返回*/
}
}

/*双偶数阶幻方，采用对调法*/

/*对调法的基础，4阶双偶。注意要求是将非主副对角线上的元素对调，
其实换个角度，你也可以说就是把祝福对角线中心对调。只不过两种思路得到的矩阵
正好是反着来的*/
/*本函数实现主副对角线互调*/
void mean_double_4(int size)
{

int i;
int total = size * size +1 ;
for(i = 0; i < EVEN_DOUBLE_4; i++){
Magic[row+i][column+i] = total - Magic[row+i][column+i];
Magic[row+i][ EVEN_DOUBLE_4+column-i-1] =
total - Magic[row+i][ EVEN_DOUBLE_4+column-i-1];
}

}

/*任意阶双偶*/
void mean_double(int size)
{
int num; //填充数字
int min_num = 1;
int max_num = 1+size*size; //填充范围
int i = 0; //循环变量
int temp;

/*双偶，初始化*/
for(num = min_num; num < max_num; num++){
Magic[row][column] = num;
if((num ) % (size ) == 0){
column = 0, row++;
}
else column++;
}

/*分割为4×4的小矩阵*/
row = 0; column = 0;
temp = size / EVEN_DOUBLE_4;

for(i = 1; i <=temp *temp; i++){
mean_double_4(size);
if(i % temp == 0) column = 0, row += 4 ;
else column = (i % temp) * EVEN_DOUBLE_4;
}
}

/*单偶，用楼梯法*/
void mean_single(int size)
{
int i,j,k,m;
int temp;

/*分象限处理，
14
32
与普通直角坐标系象限区别，说白了，就是个分块的概念
*/
row = 0, column = 0; //第一象限
odd(size/2, 0);

row = size/2, column = size/2; //第二象限
odd(size/2, (size*size)/4*1);

row = 0, column = size/2; //第三象限
odd(size/2, (size*size)/4*2);

row = size/2, column = 0; //第四象限
odd(size/2, (size*size)/4*3);

m = size / 4;

/*对换*/
for(i = 0; i< size/2; i++){
/*1、3象限对换*/
for(j = 0; j<m; j++ ){
if(i == m) k = j + m;
else k = j;
temp = Magic[i][k];
Magic[i][k] = Magic[i + 2*size/4 ][k];
Magic[i + 2*size/4 ][k] = temp;
}
/*2，4对换*/
for(j = 0; j<m-1; j++ ){
k = 3*size/4 +j;
temp = Magic[i][k];
Magic[i][k] = Magic[i + 2*size/4][k];
Magic[i + 2*size/4][k] = temp;
}
}
}

/*打印幻方*/
void print_magic(int size)
{
int i,j;
for(i = 0; i < size; i++)
for(j = 0; j < size; j++){
printf("%4d", Magic[i][j]);
if(j == size -1) putchar('\n');
}
putchar('\n');
}

/*打印各行、各列、各对角线数据之和*/
void sum_print(int data[], int size)
{
int i,j;

/*打印每行数据之和*/
printf("行之和：");
for(i = 0; i < size; i++)
for(j = 0; j < size; j++){
data[i] += Magic[i][j]; //行之和
if (j == size -1) printf("%6d", data[i]);
}
putchar('\n');

/*打印每列数据之和*/
printf("列之和：");
for(i = 0; i < size; i++)
for(j = 0; j < size; j++){
data[size+i] += Magic[j][i]; //列之和
if (j == size -1) printf("%6d", data[size+i]);
}
putchar('\n');

/*打印主对角线之和*/
for(i=0; i<size; i++)
data[2*size] += Magic[i][i];
printf("主对角线之和：%6d", data[2*size]);
putchar('\n');

/*打印副对角线之和*/
for(i=0; i<size; i++)
data[2*size+1] += Magic[i][size-i-1];
printf("主对角线之和：%6d", data[2*size]);
putchar('\n');

}

/*行列对和数组清零*/
void clear_sum(int data[])
{
int i;
for(i = 0; i < 2 * MAX_SIZE; i++)
data[i] = 0;
}

/*检查程序是否运转正常，所得结果是否是幻方*/
void check_magic(int data[], int size )
{
int i;
int flag = 0;
for(i=1; i<size+2;i++)
if(data[0]-data[i]) flag = 1;
if(flag) printf("程序出错，Esc退出，Enter继续\n");
else printf("\n恭喜你，获得了一个新的%d阶幻方!\n", size);
putchar('\n');

}

㈣ 已知一个无序数组a[ n ],试编写一算法,实现数组的升序排列。

#include "stdio.h"
#include "stdlib.h"
#include "malloc.h"
#include "conio.h"
#include "windows.h"
#define N 8
int a[N];

void init(int a[]) //将排序的数字输入
{
int i;
printf("请输入[%d]个数字:\n",N);
for(i=0;i<N;i++)
scanf("%d",&a[i]);
}
void print(int a[]) // 打印
{
int i;
for(i=0;i<N;i++)
printf("%5d",a[i]);
printf("\n\n");
}

void sort(int a[])//排序
{
int i,j,x;
for(i=1;i<N;i++)
{
x=a[i];
j=i-1;
while((j>=0)&&(a[j]>x))
{
a[j+1]=a[j];
j--;
}

a[j+1]=x;
}
}

/*void main()
{
printf("现在开始排序!\n");
init(a);
system("cls");
print(a);
sort(a);
print(a);
}*/

void main()
{

char ch;
int h,temp=0;
labl:
system("cls");
printf("\t\t===========================================\n\n");
printf("\t\t---------------【1】.将排序的数字输入----\n\n");
printf("\t\t---------------【2】.排序----------------\n\n");
printf("\t\t---------------【3】.打印----------------\n\n");
printf("\t\t---------------【4】.退出----------------\n\n");

talla:
printf("请输入数字选项:_");
scanf("%d",&h);
switch(h)
{

case 1:

case 1: loop_1:
init(a);
printf("\n 添加成功 ！\n");
printf("是否重新 【Y/N】:_");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
Sleep(500);
goto loop_1;
}
else{

printf("\n是否返回 【Y/N】:_");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
Sleep(500);
goto loop_1;
}
else{
printf("\n谢谢 使用 !\n");
exit(0);
}
}

case 2:
printf("\n未排序数字(一共有【%d】个数字) :\n",N);
print(a);
printf("\n排序后的数字：\n");
sort(a);
print(a);
printf("\n是否返回菜单 【Y/N】:\n");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
printf("\n正在返回菜单.....!\n");
Sleep(500);
goto labl;
}
else
{
printf("谢谢 使用 !\n");
exit(0);
}

case 3:

printf("\n一共有【%d】个数字 :\n",N);
print(a);
printf("\n 是否返回菜单 【Y/N】:_");
fflush(stdin);
ch=getchar();
printf("%c",ch);
if(ch=='y'||ch=='Y')
{
printf("正在返回菜单.....!");
Sleep(500);
goto labl;
}
else
{
printf("谢谢 使用 !\n");
exit(0);
}

case 4: printf("谢谢 使用"); exit(0);

default: printf("输入 有误 请重 输入 !");
goto talla;

}

}

㈤ 常见决策树分类算法都有哪些

在机器学习中，有一个体系叫做决策树，决策树能够解决很多问题。在决策树中，也有很多需要我们去学习的算法，要知道，在决策树中，每一个算法都是实用的算法，所以了解决策树中的算法对我们是有很大的帮助的。在这篇文章中我们就给大家介绍一下关于决策树分类的算法，希望能够帮助大家更好地去理解决策树。
1.C4.5算法
C4.5算法就是基于ID3算法的改进，这种算法主要包括的内容就是使用信息增益率替换了信息增益下降度作为属性选择的标准；在决策树构造的同时进行剪枝操作；避免了树的过度拟合情况；可以对不完整属性和连续型数据进行处理；使用k交叉验证降低了计算复杂度；针对数据构成形式，提升了算法的普适性等内容，这种算法是一个十分使用的算法。
2.CLS算法
CLS算法就是最原始的决策树分类算法，基本流程是，从一棵空数出发，不断的从决策表选取属性加入数的生长过程中，直到决策树可以满足分类要求为止。CLS算法存在的主要问题是在新增属性选取时有很大的随机性。
3.ID3算法
ID3算法就是对CLS算法的最大改进是摒弃了属性选择的随机性，利用信息熵的下降速度作为属性选择的度量。ID3是一种基于信息熵的决策树分类学习算法，以信息增益和信息熵，作为对象分类的衡量标准。ID3算法结构简单、学习能力强、分类速度快适合大规模数据分类。但同时由于信息增益的不稳定性，容易倾向于众数属性导致过度拟合，算法抗干扰能力差。
3.1.ID3算法的优缺点
ID3算法的优点就是方法简单、计算量小、理论清晰、学习能力较强、比较适用于处理规模较大的学习问题。缺点就是倾向于选择那些属性取值比较多的属性，在实际的应用中往往取值比较多的属性对分类没有太大价值、不能对连续属性进行处理、对噪声数据比较敏感、需计算每一个属性的信息增益值、计算代价较高。
3.2.ID3算法的核心思想
根据样本子集属性取值的信息增益值的大小来选择决策属性，并根据该属性的不同取值生成决策树的分支，再对子集进行递归调用该方法，当所有子集的数据都只包含于同一个类别时结束。最后，根据生成的决策树模型，对新的、未知类别的数据对象进行分类。
在这篇文章中我们给大家介绍了决策树分类算法的具体内容，包括有很多种算法。从中我们不难发现决策树的算法都是经过不不断的改造趋于成熟的。所以说，机器学习的发展在某种程度上就是由于这些算法的进步而来的。

㈥ 二叉树求叶子结点个数算法（c++）

以前收集的代码，贴给你，希望对你能有所帮助.二叉树的代码实现如下：
// FileName : btree.h#ifndef __BINARY_TREE_H__
#define __BINARY_TREE_H__#include <assert.h>
#include <crtdbg.h>#ifdef _DEBUG
#define DEBUG_NEW new (_NORMAL_BLOCK, THIS_FILE, __LINE__)
#endif#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif#ifdef _DEBUG
#ifndef ASSERT
#define ASSERT assert
#endif
#else // not _DEBUG
#ifndef ASSERT
#define ASSERT
#endif
#endif // _DEBUGtemplate<typename T>
class CBTNode
{
public:
T data;
CBTNode<T> *parent;
CBTNode<T> *left;
CBTNode<T> *right;
CBTNode(
T data = T(),
CBTNode<T> *parent = NULL,
CBTNode<T> *left = NULL,
CBTNode<T> *right = NULL
) : data(data), parent(parent), left(left), right(right) {}
};template<typename T>
class CBTree
{
protected:
CBTNode<T> *m_pNodeRoot;public:
CBTree(CBTNode<T> *initroot = NULL);
~CBTree();
void AssignTo(CBTNode<T> *p);
void Copy(CBTree<T> &p);private:
CBTNode<T>* Copy(CBTNode<T> *p); void DestroyNode(CBTNode<T> *p); void PreOrderTraverse(
const CBTNode<T> *p,
void (*Visit)(const T &data)
) const; void InOrderTraverse(
const CBTNode<T> *p,
void (*Visit)(const T &data)
) const; void PostOrderTraverse(
const CBTNode<T> *p,
void (*Visit)(const T &data)
) const; void GetNodesCount(const CBTNode<T> *p, unsigned int *unCount) const; void GetLeafCount(const CBTNode<T> *p, unsigned int *unCount) const;public:
T& GetNodeData(CBTNode<T> *p);
T GetNodeData(const CBTNode<T> *p) const;
void SetNodeData(CBTNode<T> *p, const T &data);
CBTNode<T>*& GetRoot();
CBTNode<T>* GetRoot() const;
CBTNode<T>*& GetParent(CBTNode<T> *p);
CBTNode<T>* GetParent(const CBTNode<T> *p) const;
CBTNode<T>*& GetLeftChild(CBTNode<T> *p);
CBTNode<T>* GetLeftChild(const CBTNode<T> *p) const;
CBTNode<T>*& GetRightChild(CBTNode<T> *p);
CBTNode<T>* GetRightChild(const CBTNode<T> *p) const;
CBTNode<T>*& GetLeftSibling(CBTNode<T> *p);
CBTNode<T>* GetLeftSiblig(const CBTNode<T> *p) const;
CBTNode<T>*& GetRightSibling(CBTNode<T> *p);
CBTNode<T>* GetRightSibling(const CBTNode<T> *p) const;public:
int IsEmpty() const;
void Destroy();
void PreOrderTraverse(void (*Visit)(const T &data)) const;
void InOrderTraverse(void (*Visit)(const T &data)) const;
void PostOrderTraverse(void (*Visit)(const T &data)) const;
unsigned int GetNodesCount() const; // Get how many nodes
unsigned int GetLeafCount() const;
unsigned int GetDepth() const;
unsigned int GetDepth(const CBTNode<T> *p) const;
};template<typename T>
inline CBTree<T>::CBTree(CBTNode<T> *initroot) : m_pNodeRoot(initroot)
{
}template<typename T>
inline CBTree<T>::~CBTree()
{
Destroy();
}template<typename T>
inline void CBTree<T>::AssignTo(CBTNode<T> *p)
{
ASSERT(p);
m_pNodeRoot = p;
}template<typename T>
inline void CBTree<T>::Copy(CBTree<T> &p)
{
if (NULL != p.m_pNodeRoot)
m_pNodeRoot = Copy(p.m_pNodeRoot);
else
m_pNodeRoot = NULL;
}template<typename T>
inline CBTNode<T>* CBTree<T>::Copy(CBTNode<T> *p)
{
if (p)
{
CBTNode<T> *pNewNode = new CBTNode<T>;
if (NULL == pNewNode)
return NULL;
pNewNode->data = p->data;
pNewNode->parent = p->parent;
pNewNode->left = Copy(p->left);
pNewNode->right = Copy(p->right);
return pNewNode;
}
else
return NULL;
}template<typename T>
inline CBTNode<T>*& CBTree<T>::GetLeftChild(CBTNode<T> *p)
{
ASSERT(p);
return *(&(p->left));
}template<typename T>
inline CBTNode<T>* CBTree<T>::GetLeftChild(const CBTNode<T> *p) const
{
ASSERT(p);
return p->left;
}template<typename T>
inline CBTNode<T>*& CBTree<T>::GetRightChild(CBTNode<T> *p)
{
ASSERT(p);
return *(&(p->right));
}template<typename T>
inline CBTNode<T>* CBTree<T>::GetRightChild(const CBTNode<T> *p) const
{
ASSERT(p);
return p->right;
}template<typename T>
inline CBTNode<T>*& CBTree<T>::GetLeftSibling(CBTNode<T> *p)
{
ASSERT(p); if (p->parent)
return *(&(p->parent->left));
else
return *(&(p->parent)); // return NULL;
}template<typename T>
inline CBTNode<T>* CBTree<T>::GetLeftSiblig(const CBTNode<T> *p) const
{
ASSERT(p); if (p->parent)
return p->parent->left;
else
return p->parent; // return NULL;
}template<typename T>
inline CBTNode<T>*& CBTree<T>::GetRightSibling(CBTNode<T> *p)
{
ASSERT(p); if (p->parent)
return *(&(p->parent->right));
else
return *(&(p->parent)); // return NULL;
}template<typename T>
inline CBTNode<T>* CBTree<T>::GetRightSibling(const CBTNode<T> *p) const
{
ASSERT(p); if (p->parent)
return p->parent->right;
else
return p->parent; // return NULL;
}template<typename T>
inline CBTNode<T>*& CBTree<T>::GetParent(CBTNode<T> *p)
{
ASSERT(p);
return *(&(p->parent));
}template<typename T>
inline CBTNode<T>* CBTree<T>::GetParent(const CBTNode<T> *p) const
{
ASSERT(p);
return p->parent;
}template<typename T>
inline T& CBTree<T>::GetNodeData(CBTNode<T> *p)
{
ASSERT(p);
return p->data;
}template<typename T>
inline T CBTree<T>::GetNodeData(const CBTNode<T> *p) const
{
ASSERT(p);
return p->data;
}template<typename T>
inline void CBTree<T>::SetNodeData(CBTNode<T> *p, const T &data)
{
ASSERT(p);
p->data = data;
}template<typename T>
inline int CBTree<T>::IsEmpty() const
{
return NULL == m_pNodeRoot;
}template<typename T>
inline CBTNode<T>*& CBTree<T>::GetRoot()
{
return *(&(m_pNodeRoot));
}template<typename T>
inline CBTNode<T>* CBTree<T>::GetRoot() const
{
return m_pNodeRoot;
}template<typename T>
inline void CBTree<T>::DestroyNode(CBTNode<T> *p)
{
if (p)
{
DestroyNode(p->left);
DestroyNode(p->right);
delete p;
}
}template<typename T>
inline void CBTree<T>::Destroy()
{
DestroyNode(m_pNodeRoot);
m_pNodeRoot = NULL;
}template<typename T>
inline void CBTree<T>::PreOrderTraverse(void (*Visit)(const T &data)) const
{
PreOrderTraverse(m_pNodeRoot, Visit);
}template<typename T>
inline void CBTree<T>::PreOrderTraverse(
const CBTNode<T> *p,
void (*Visit)(const T &data)
) const
{
if (p)
{
Visit(p->data);
PreOrderTraverse(p->left, Visit);
PreOrderTraverse(p->right, Visit);
}
}template<typename T>
inline void CBTree<T>::InOrderTraverse(void (*Visit)(const T &data)) const
{
InOrderTraverse(m_pNodeRoot, Visit);
}template<typename T>
inline void CBTree<T>::InOrderTraverse(
const CBTNode<T> *p,
void (*Visit)(const T &data)
) const
{
if (p)
{
InOrderTraverse(p->left, Visit);
Visit(p->data);
InOrderTraverse(p->right, Visit);
}
}template<typename T>
inline void CBTree<T>::PostOrderTraverse(void (*Visit)(const T &data)) const
{
PostOrderTraverse(m_pNodeRoot, Visit);
}template<typename T>
inline void CBTree<T>::PostOrderTraverse(
const CBTNode<T> *p,
void (*Visit)(const T &data)
) const
{
if (p)
{
PostOrderTraverse(p->left, Visit);
PostOrderTraverse(p->right, Visit);
Visit(p->data);
}
}template<typename T>
inline unsigned int CBTree<T>::GetNodesCount() const
{
unsigned int unCount;
GetNodesCount(m_pNodeRoot, &unCount);
return unCount;
}template<typename T>
inline void CBTree<T>::GetNodesCount(
const CBTNode<T> *p,
unsigned int *unCount
) const
{
ASSERT(unCount); unsigned int unLeftCount;
unsigned int unRightCount; if (NULL == p)
*unCount = 0;
else if ((NULL == p->left) && (NULL == p->right))
*unCount = 1;
else
{
GetNodesCount(p->left, &unLeftCount);
GetNodesCount(p->right, &unRightCount);
*unCount = 1 + unLeftCount + unRightCount;
}
}template<typename T>
inline unsigned int CBTree<T>::GetLeafCount() const
{
unsigned int unCount = 0;
GetLeafCount(m_pNodeRoot, &unCount);
return unCount;
}template<typename T>
inline void CBTree<T>::GetLeafCount(
const CBTNode<T> *p,
unsigned int *unCount
) const
{
ASSERT(unCount); if (p)
{
// if the node's left & right children are both NULL, it must be a leaf
if ((NULL == p->left) && (NULL == p->right))
++(*unCount);
GetLeafCount(p->left, unCount);
GetLeafCount(p->right, unCount);
}
}template<typename T>
inline unsigned int CBTree<T>::GetDepth() const
{
// Minus 1 here because I think the root node's depth should be 0.
// So, don't do it if u think the root node's depth should be 1.
return GetDepth(m_pNodeRoot) - 1;
}template<typename T>
inline unsigned int CBTree<T>::GetDepth(const CBTNode<T> *p) const
{
unsigned int unDepthLeft;
unsigned int unDepthRight; if (p)
{
unDepthLeft = GetDepth(p->left);
unDepthRight = GetDepth(p->right);
return 1 + // if don't plus 1 here, the tree's depth will be always 0
(unDepthLeft > unDepthRight ? unDepthLeft : unDepthRight);
}
else
return 0;
}#endif // __BINARY_TREE_H__

㈦ 数据结构：用什么算法可以走出迷宫

算法应该很多的，循环的，递归的，还有用栈的我有两个可以看看，第一个是网络上下的，后面的是我自己编的和修改的
1.
//////////////////////////////////////////////////////////////////////
//文件名 :Maze.cpp

//功能 : 线性表的应用——迷宫求解

//创建 : 2007.6.20

//修改日期 : 2007.6.20

//作者 :

////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include <iostream>
#include <stdio.h>
#include<time.h>
//#include "format.h"
//#include "stack.h"
using namespace std;

#define OK 0
#define ERR -1
#define UP '↑' //用于存储方向的常量
#define DOWN '↓'
#define LEFT '→'
#define RIGHT '←'
#define Rank 20
#define File 63
#define Rand 16

char Maze[Rank][File]; //定义存储迷宫用的字符型二维数组
char mark=1; //标记
char Bar=2; //地图
char Player=12; //游戏者

typedef struct SNode
{
int data;
struct SNode *next;
}SNode;

typedef struct
{
int length;
SNode *top;
}STACK;

void InitStack(STACK *S)
{
S->top=NULL;
S->length=0;
}

/*元素e入栈*/
int Push(STACK *S,int e)
{
SNode *p;
p=new SNode[sizeof(SNode)];
if(!p) return ERR;
p->data=e;
p->next=S->top;
S->top=p;
S->length++;
return OK;
}

/*栈顶元素出栈,e带回栈顶元数*/
int Pop(STACK *S,int *e)
{
SNode *p;
if(S->top==NULL) return ERR;
p=S->top;
*e=p->data;
S->top=p->next;
S->length--;
delete p;
return OK;
}

/*判断S是否为空栈*/
int Empty(STACK S)
{
if(S.top==NULL) return OK;
return ERR;
}

void ShowMaze();
void InitMaze();
void RunMaze();

int main()
{
int i=1;
system("color 1E");
while(i==1)
{
RunMaze();
cout<<"\t\t ‘选择：Prsss 1：再来一次 Else：退出程序’\n";
cin>>i;
}
return 0;
}

void ShowMaze()
{
int i,j;
system("cls");
cout<<"\n\t\t\t ‘迷 宫 求 解’"<<"\n";
cout<<"\t\t ‘注:"<<Player<<"为游戏者"<<Bar<<"为地图障碍"<<mark<<"为所留印记’"<<endl;
for(i=0;i<Rank;i++)
{
cout<<"\t"<<Bar;
for(j=0;j<File;j++)
cout<<Maze[i][j];
cout<<Bar<<"\n";
}
}

void InitMaze()
{
int i,j;
for(i=0;i<Rank;i++)
for(j=0;j<File;j++)
Maze[i][j]=Bar;
srand((unsigned)time(NULL));
int n;
cout<<"请输入数字选图";
cin>>n;
for(i=1;i<Rank-1;i++) //for开始
for(j=1;j<File;j++)
{
//n=rand()%Rand; //随机函数
//if(n<Rand*2/3) Maze[i][j]=' ';
if (((n^i+4*j^3))%11!=5)Maze[i][j]=' ';
} //for结束
Maze[1][0]=' '; //给迷宫留入口
Maze[1][1]=' ';
Maze[1][2]=' ';
Maze[1][3]=' ';
Maze[Rank-2][File-4]=' '; //给迷宫留出口
Maze[Rank-2][File-3]=' ';
Maze[Rank-2][File-2]=' ';
Maze[Rank-2][File-1]=' ';
}

void RunMaze()
{
int path,i=1,j=0,speed=0;
time_t Start,End;
STACK S; //定义一个用于存储走过的路线的栈
time(&Start);
InitMaze(); //随机成生迷宫
InitStack(&S); //初始化栈
Maze[1][0]=Player; //初始化位置
ShowMaze(); //显示迷宫
cout<<"\n\t\t\t‘请选择速度:1 快速 2 较慢 ’"<<endl;
while(speed!=1 && speed!=2) cin>>speed;
while(i>=0 && i<Rank && j>=0 && j<File)//开始遍历迷宫
{
ShowMaze(); //显示迷宫
if(speed==2) //选择2较慢时进入空循环延时
Sleep(100);
if(i==Rank-2&&j==File-1) //判断是否到达出口
{
time(&End);
cout<<"\n\t\t‘恭喜成功走出!所用的步数为:"<<S.length<<" 所用时间："<<End-Start<<" 秒’"<<endl;
return;
}
if(Maze[i][j+1]==' ') //向右走一步
{
char dir=26;
Maze[i][j]=dir;
j=j+1;
Maze[i][j]=Player;
Push(&S,RIGHT);
}
else
{
if(Maze[i+1][j]==' ') //向下走一步
{
char dir=25;
Maze[i][j]=dir;
i=i+1;
Maze[i][j]=Player;
Push(&S,DOWN);
}
else
{
if(Maze[i-1][j]==' ') //向上走一步
{
char dir=24;
Maze[i][j]=dir;
i=i-1;
Maze[i][j]=Player;
Push(&S,UP);
}
else
{
if(Maze[i][j-1]==' ') //向左走一步
{
char dir=27;
Maze[i][j]=dir;
j=j-1;
Maze[i][j]=Player;
Push(&S,LEFT);
}
else //遇到障碍往回走一步
{
if(Empty(S)==OK) //判断是否回到起点了,是则退出程序
{
time(&End);
cout<<"\n\t\t\t‘迷宫没有出路! 所用时间："<<End-Start<<"秒’\n";
return;
}
else
{
if(Pop(&S,&path)==OK) //判断能否取回上一步路径
{
switch(path)
{
case LEFT:
Maze[i][j]=mark;
j=j+1;
Maze[i][j]=Player;
break;
case UP:
Maze[i][j]=mark;
i=i+1;
Maze[i][j]=Player;
break;
case DOWN:
Maze[i][j]=mark;
i=i-1;
Maze[i][j]=Player;
break;
case RIGHT:
Maze[i][j]=mark;
j=j-1;
Maze[i][j]=Player;
break;
} //结束分支语句switch
} //结束判断能否取回上一步路径
}
}
}
}
}
} //结束while循环
}
第二个。

#include <windows.h>
#include <iostream>
#include <stdio.h>
#include<time.h>
//#include "format.h"
//#include "stack.h"
using namespace std;

//#define OK 0
//#define ERR -1
//#define UP '↑' //用于存储方向的常量
//#define DOWN '↓'
//#define LEFT '→'
//#define RIGHT '←'
#define Rank 17
#define File 63
#define Rand 16

char Maze[Rank][File]; //定义存储迷宫用的字符型二维数组
char mark=1; //标记
char Bar=2; //地图
char Player=12; //游戏者

void ShowMaze();
void InitMaze();
void RunMaze();

int main()
{
int i=1;
system("color 1E");
while(i==1)
{
RunMaze();
cout<<"\t\t ‘选择：Prsss 1：再来一次 Else：退出程序’\n";
cin>>i;
}
return 0;
}

void ShowMaze()
{
int i,j;
system("cls");
cout<<"\n\t\t\t ‘迷 宫 求 解’"<<"\n";
cout<<"\t\t ‘注:"<<Player<<"为游戏者"<<Bar<<"为地图障碍"<<mark<<"为所留印记’"<<endl;
for(i=0;i<Rank;i++)
{
cout<<"\t"<<Bar;
for(j=0;j<File;j++)
cout<<Maze[i][j];
cout<<Bar<<"\n";
}
}

void InitMaze()
{
int i,j;
for(i=0;i<Rank;i++)
for(j=0;j<File;j++)
Maze[i][j]=Bar;
srand((unsigned)time(NULL));
int n=5;
cout<<"请输入数字选图";
cin>>n;
for(i=1;i<Rank-1;i++) //for开始
for(j=1;j<File;j++)
{
//n=rand()%Rand; //随机函数
//if(n<Rand*2/3) Maze[i][j]=' ';

if (((n^i+4*j^3))%5!=1)Maze[i][j]=' ';
} //for结束
Maze[1][0]=' '; //给迷宫留入口
Maze[1][1]=' ';
Maze[1][2]=' ';
Maze[1][3]=' ';
Maze[Rank-2][File-4]=' '; //给迷宫留出口
Maze[Rank-2][File-3]=' ';
Maze[Rank-2][File-2]=' ';
Maze[Rank-2][File-1]=' ';
}

void RunMaze()
{ int a=2;
int i=1,j=1,speed=0;
time_t Start,End;
//STACK S; //定义一个用于存储走过的路线的栈
time(&Start);
InitMaze(); //随机成生迷宫
//InitStack(&S); //初始化栈
//Maze[1][0]=Player; //初始化位置
ShowMaze(); //显示迷宫
cout<<"\n\t\t\t‘请选择速度:1 快速 2 较慢 ’"<<endl;
while(speed!=1 && speed!=2) cin>>speed;
while(i>=0 && i<Rank && j>=0 && j<File)//开始遍历迷宫
{
ShowMaze(); //显示迷宫
if(speed==2) //选择2较慢时进入空循环延时
Sleep(100);
if(i==Rank-2&&j==File-1) //判断是否到达出口
{
time(&End);
cout<<"\n\t\t‘恭喜成功走出!"<<" 所用时间："<<End-Start<<" 秒’"<<endl;
return ;
}
else
{
switch(a)
{

case 1:if (Maze[i-1][j]==' '||Maze[i-1][j]==26)
{i=i-1;
a=-2;
Maze[i][j]=26;
break;
}
else
if (Maze[i][j+1]==' '||Maze[i][j+1]==26)
{j=j+1;
a=1;
Maze[i][j]=26;
break;
}else
if (Maze[i+1][j]==' '||Maze[i+1][j]==26)
//if(Maze[i+1]][j]==' '||Maze[i+1][j]==26)
{i=i+1;
a=2;
Maze[i][j]=26;
break;
}
else
{
Maze[i][j]=26;
a=-a;
break;
}

case 2:if(Maze[i][j+1]==' '||Maze[i][j+1]==26)
{
j=j+1;
a=1;
Maze[i][j]=26;
break;
}
else
if(Maze[i+1][j]==' '||Maze[i+1][j]==26)
{
i=i+1;
a=2;
Maze[i][j]=26;
break;
}
else
if(Maze[i][j-1]==' '||Maze[i][j-1]==26)
{
j=j-1;
a=-1;
Maze[i][j]=26;
break;
}
else
{
Maze[i][j]=26;
a=-a;
break;
}
case -1:if (Maze[i+1][j]==' '||Maze[i+1][j]==26)
{i=i+1;
a=2;
Maze[i][j]=26;
break;
}
else
if (Maze[i][j-1]==' '||Maze[i][j-1]==26)
{j=j-1;
a=-1;
Maze[i][j]=26;
break;
}
else
if (Maze[i-1][j]==' '||Maze[i-1][j]==26)
{i=i-1;
a=-2;
Maze[i][j]=26;
break;
}
else
{
a=-a;
Maze[i][j]=26;
break;

}

case -2:if (Maze[i][j-1]==' '||Maze[i][j-1]==26)
{j=j-1;
a=-1;
Maze[i][j]=26;
break;
}
else
if (Maze[i-1][j]==' '||Maze[i-1][j]==26)
{i=i-1;
a=-2;
Maze[i][j]=26;
break;
}
else
if (Maze[i][j+1]==' '||Maze[i][j+1]==26)
{j=j+1;
a=1;
Maze[i][j]=26;
break;
}
else
{
Maze[i][j]=26;
a=-a;
break;
}

}
if (i==1&&j==1)
{
time(&End);
cout<<"迷宫没有出路"<<"所用时间"<<End-Start<<endl;
return;
}
}
} //结束while循环
}

㈧ 多级队列调度算法和多级反馈队列的调度算法 优缺点

#include "stdio.h"
#include <stdlib.h>
#include <conio.h>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
int time[3];
struct program { /* 定义进程控制块PCB */
char name[10];
char state;
int queue;//进程队列
int priority; // 数字越小优先级越高
int needtime;//需运行时间
int runtime; //已经运行时间
struct program *link;
}*ready=NULL;
typedef struct program PROGRAM;
PROGRAM *run=NULL,*head1=NULL,*head2=NULL,*head3=NULL,*end1=NULL,*end2=NULL,*end3=NULL;
/*PROCESS *high_priority(PROCESS *P) //选择优先级最高的进程
{
PROCESS *q,*p; //问题，入口形参中
q=p;

while(p->next!=NULL)
{
if(q->priority>p->priority)
q=p;
p=p->next;
}
return q;
}*/

void sort(PROGRAM *p)
{switch(p->queue)
{case 1:
{if(head1==NULL) {head1=p;end1=p;}
else
{end1->link=p;end1=p;p->link=NULL;}
p->state='w';
break;
}
case 2:
{if(head2==NULL)
{head2=p;end2=p;p->state='w';}
else
{end2->link=p;end2=p;p->link=NULL;}
p->state='w';
break;
}
case 3:
{if(head3==NULL)
{head3=p;end3=p;}
else
{end3->link=p;end3=p;p->link=NULL;}
p->state='w';
break;
}
}
}
void input() /* 建立进程控制块函数*/
{ PROGRAM *p;
int i,num;
/*clrscr(); 清屏*/
system("cls");
printf("\n 多级反馈队列调度算法 \n");
printf("\n 请输入进程个数:\n");
scanf("%d",&num);

//printf("\n qname \t state \t queue \t needtime \t runtime \n");
printf("\n 输入第一个进程名:");
ready=getpch(PROGRAM);
scanf("%s",ready->name);
printf("\n 输入第一个进程优先级:");
scanf("%d",&ready->priority);
printf("\n 输入第一个进程运行时间:");

scanf("%d",&ready->needtime);
printf("\n");
ready->runtime=0;ready->state='r';
ready->queue=1;
ready->link=NULL;

for(i=0;i<num-1;i++)
{ printf("\n 进程号No.%d:\n",i+2);
p=getpch(PROGRAM);
printf("\n 输入进程名:");
scanf("%s",p->name);
printf("\n 输入进程优先级:");
scanf("%d",&ready->priority);
p->queue=1;
//printf("\n 输入进程队伍数1~3:");
//scanf("%d",&p->queue);
printf("\n 输入进程运行时间:");
scanf("%d",&p->needtime);
printf("\n");
p->runtime=0;p->state='w';
p->link=NULL;
sort(p);
}
}
void disp(PROGRAM * pr) /*建立进程显示函数,用于显示当前进程*/
{
printf("\n qname\t priority\t state\t queue\t needtime\t runtime \n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->priority);
printf("|%c\t",pr->state);
printf("|%d\t",pr->queue);
printf("|%d\t",pr->needtime);
printf("|%d\t",pr->runtime);
printf("\n");
}
void check()//进程查看函数
{PROGRAM *pr;
printf("\n****当前正在运行的进程%s",run->name);
disp(run);
printf("\n****当前正准备好的进程%s",ready->name);
if(ready!=NULL)
{disp(ready);
printf("\n****当前就绪的队列状态为:\n");}
pr=head1;
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
pr=head2;
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
pr=head3;
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}
//三个队伍的进程的执行函数
void runpro()
{
run=ready;
if(head1!=NULL)
{ready=head1;head1=head1->link;ready->state='r';}
else
{
if(head2!=NULL)
{ready=head2;head2=head2->link;ready->state='r';}
else
{if(head3!=NULL)
{ready=head3;head3=head3->link;ready->state='r';}
else
ready=NULL;}
}
if(run!=NULL)
{check();//显示运行及等待队列的状况
run->runtime=run->runtime+time[run->queue-1];
if(run->runtime>run->needtime)
run->runtime=run->needtime;
if(run->queue<3)
run->queue+=1;
//disp(run);
if(run->runtime<run->needtime)
sort(run);
}
}
void main() /*主函数*/
{
int h=0;
char ch;
input();
time[0]=1;
time[1]=2;
time[2]=3;

while(ready!=NULL)
{
ch=getchar();
h++;//标志执行的步骤
printf("\n The execute number:%d \n",h);

runpro();
if(run->runtime==run->needtime)
{printf("\n进程%s已经完成\n",run->name);/*run=NULL;*/}
printf("\n 按任一键继续......");
ch=getchar();
}
printf("整个进程运行完毕");
}

㈨ 谁帮忙解释一下该C语言的算法思想

这是一个学生信息管理系统，可以做添加学生信息，显示所有学生信息，查找学生信息，删除学生信息，对学生信息排序，退出学生信息这些操作。

用一个结构类型student来表示每个学生的信息：
struct student
{
int id; //学号
char name[10]; //名字
int age; //年龄
char sex[5]; //性别
}stu[50];

每个学生信息有学号，名字，年龄，性别，共定义了50个学生。

int menu_1() //定义菜单1
{
int c;
system("cls"); //清屏
printf("\t___________________学生信息管理系统___________________\n");
printf("\t\t\t1： 添加学生信息\n");
printf("\t\t\t2： 显示所有学生信息\n");
printf("\t\t\t3： 查找学生信息\n");
printf("\t\t\t4： 删除学生信息\n");
printf("\t\t\t5： 对学生信息排序\n");
printf("\t\t\t6： 退出学生信息\n");
printf("\t======================================================\n");
printf("\t\t\t请输入您的选择：");
scanf("%d",&c); //接收定量C
return(c); //返还C
}
运行这一段程序会显示一个菜单如下：

___________________学生信息管理系统___________________
1： 添加学生信息
2： 显示所有学生信息
3： 查找学生信息
4： 删除学生信息
5： 对学生信息排序
6： 退出学生信息
======================================================
请输入您的选择：

有6个选项你可以选择，在你输入你的选择之后，就进行相应的操作。
如果你输入1，则进行添加学生信息的操作，转到程序
void tianjia() //添加信息
{
printf("请输入要添加的学生信息:\n\n");
printf("请输入学号\n"); //学号
scanf("%d",&stu[n].id);
printf("请输入名字\n"); //姓名
scanf("%s",stu[n].name);
printf("请输入年龄(1-99)\n"); //年龄
scanf("%d",&stu[n].age);
getchar();
printf("请输入性别(W或者M)\n");//性别
scanf("%s",stu[n].sex);
n++;
}

一个个学生的输入他们的学号，姓名，年龄和性别，存到数组stu[]中。
如果你选择2、显示所有学生信息，则转到程序:

void xianshi() //显示所有信息
{
printf("显示所有学生信息:\n\n");
int j;
printf("\t学号\t姓名\t年龄\t性别\n");
for(j=0;j<n;j++)
printf("\t%d\t%s\t%d\t%s\n",stu[j].id,stu[j].name,stu[j].age,stu[j].sex);
}
这个程序将刚才添加的学生信息全部显示到屏幕上。

如果你输入3，则选择3、查找学生信息，开始查找学生信息，转到程序：

void chazhao() // 查找学生信息
{
int m;
char name[20],b;
do
{
printf("请输入想查找的学生姓名:\n\n");
fflush(stdin);
gets(name);
for(m=0;m<n;m++)
{
if(strcmp(name,stu[m].name)==0)
{
printf("\n\t已找到您要查找的信息\n",m+1);
break;
}
}
if(m>=20)
printf("\n\n没有查找到该信息，请确定是否有误\n");
else
{
printf("\t学号\t姓名\t年龄\t性别\n");
printf("\t%d\t%s\t%d\t%s\t",
stu[m].id,stu[m].name,stu[m].age,stu[m].sex);
}
printf("\n是否查找另一个学生的信息?(y/n)");
fflush(stdin);
b=getchar();

}while(b=='y');
}
这段程序把你想要找的学生的信息显示出来。

如果你选择4、删除学生信息，则进行删除指定学生的信息，转到程序：

void shanchu() // 删除学生信息
{
char name[20],c;
int a,b;
do
{
printf("请输入要删除的学生姓名:\n\n");
fflush(stdin);
gets(name);
for(a=0;a<n;a++)
{
if(strcmp(name,stu[a].name)==0)
break;
}
for(b=a;b<n;b++)
stu[b]=stu[b+1];
if(a>n)
printf("\t没有找到这个学生!!!\n");
else
{
n--;
xianshi();
}

printf("\n是否继续删除另一个学生信息?(y/n) ");
fflush(stdin);
c=getchar();
}while(c=='y');
}

函数的名字用拼音写得很清楚是做什么操作的，再仔细看看每一个函数是怎么实现的，就可以掌握这个程序主要实现的功能了。

㈩ 【急！在线等】求指点如何计算股权融资成本，用CLS模型

241有图图图图非要让他一人一发个给当事人应该的