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有圖圖圖圖非要讓他一人一發個給當事人應該的