思路1：
写出所有24种4个数的排列，存到一个数组里，假如数组是P[24][4]；
那么可以
for (i = 0; i < 24; i++)
for (j = 0; j < 24; j++)
for (k = 0; k < 24; k++)
三层循环，P[i],P[j],P[k]分别是矩阵的三个列
思路2：
利用dfs递归枚举
int used[3][4];/这个数组存放三个列中0～3这四个数是否已在这一列中出现过，需要提前清零/
int mat[3][4];/要枚举的矩阵/
void dfs(int col, int row)/col表示现在已经搜索到哪一列(从0开始编号)，row表示这一列已经填了几行/
{
int i;
if (col == 2 && row == 4)
{
/运行到这里的时候，mat就是枚举到的一个矩阵/
return;
}
if (row == 4)
{row = 0; col++;}
for (i = 0; i < 4; i++)
if (!used[col][i])
{
used[col][i] = 1;
mat[col][row] = i;
dfs(col, row + 1);
used[col][i] = 0;
}
return;
}
调用的时候调用dfs(0,0)
自己写的，运行通过，MFC的有点难弄，将就着用吧。
queueh//链式队列用于层序遍历树
// queueh: interface for the queue class
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_)
#define AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <iostreamh>
#include <asserth>
template<class T>
struct LinkNode
{
T data;
LinkNode<T> link;
LinkNode(LinkNode<T> ptr = NULL){link = ptr;}//仅初始化指针成员的初始函数
LinkNode(const T& item,LinkNode<T> ptr = NULL)
{data = item;link = ptr;} //初始化数据与指针成员的构造函数
};
template <class T>
class queue
{
private:
LinkNode<T> front,rear;//
public:
queue():rear(NULL),front(NULL){};//
~queue(){makeempty();};//
bool EnQueue(T &x);//
bool DeQueue(T &x);//
bool getFront(T &x);//
void makeempty();//
bool Isempty()const{return front==NULL;}//
int getSize()const;//
friend ostream &operator<<(ostream &os,queue<T> &q);//
};
template<class T>
void queue<T>::makeempty()
{
LinkNode<T> p;
while(front!=NULL)
{
p=front;
front=front->link;
delete p;
}
}
template <class T>
bool queue<T>::EnQueue(T &x)
{
if(front==NULL)
{
front=rear=new LinkNode<T>(x);
if(front==NULL)
return false;
}
else
{
rear->link=new LinkNode<T>(x);
if(rear==NULL)
return false;
rear=rear->link;
}
return true;
}
template <class T>
bool queue<T>::DeQueue(T &x)
{
if(Isempty())return false;
LinkNode<T> p=front;
x=front->data;
front=front->link;
delete p;
return true;
}
template<class T>
bool queue<T>::getFront(T &x)
{
if(Isempty())return false;
x=front->data;
return true;
}
template <class T>
int queue<T>::getSize() const
{
LinkNode<T> p=front;
int k=0;
while(p)
{
k++;
p=p->link;
}
return k;
}
#endif // !defined(AFX_QUEUE_H__6515EF6D_27AA_4799_95F8_6FE216E99F0F__INCLUDED_)
BinaryTreeh
// BinaryTreeh: interface for the BinaryTree class
//
//////////////////////////////////////////////////////////////////////
#if !defined(AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_)
#define AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <iostreamh>
typedef int T;
struct BinTreeNode
{
T data;
BinTreeNode leftChild,rightChild;
BinTreeNode():leftChild(NULL),rightChild(NULL){}
BinTreeNode(T x,BinTreeNode l=NULL,BinTreeNode r=NULL):data(x),leftChild(l),rightChild(r){}
};
class BinaryTree {
public:
BinaryTree():root(NULL){} //
BinaryTree(T value):RefValue(value) ,root(NULL){} //
~BinaryTree(){destroy(root);}/////////
void CreateBinTree(){CreateBinTree(root);}
bool IsEmpty(){return(root==NULL)true:false;}////////
BinTreeNode Parent(BinTreeNode current)/////////
{return(root==NULL||root==current)NULL:Parent(root,current);}//////
BinTreeNode LeftChild(BinTreeNode current)////
{return(current!=NULL)current->leftChild:NULL;}
BinTreeNode RightChild(BinTreeNode current)///////
{return(current!=NULL)current->rightChild:NULL;}
int Height(){return Height(root);}///////
int Size(){return Size(root);}///////
BinTreeNode getRoot()const{return root;}///////
void preOrder()///////
{preOrder(root);}
void inOrder()///////
{inOrder(root);}
void postOrder()///
{postOrder(root);}
void levelOrder()/////
{levelOrder(root);}
void destroy(){destroy(root);};
int Leaves (){return leaves(root);}
protected:
BinTreeNode root;
T RefValue;
void CreateBinTree(BinTreeNode &subTree);
bool Insert(BinTreeNode &subTree,const T &x);////////
void destroy(BinTreeNode &subTree);/////
bool Find(BinTreeNode &subTree,const T &x);///////
BinTreeNode Copy(BinTreeNode orignode);///////
int Height(BinTreeNode subTree);////////
int Size(BinTreeNode subTree);///////
BinTreeNode Parent(BinTreeNode Parent,BinTreeNode current);//////
BinTreeNode Find(BinTreeNode &subTree,const T &x)const;////////
void Traverse(BinTreeNode &subTree,ostream &out);///////
void preOrder(BinTreeNode &subTree);///////
void inOrder(BinTreeNode &subTree);///////
void postOrder(BinTreeNode &subTree);///////
void levelOrder(BinTreeNode &subtree);
int leaves(BinTreeNode &subTree);
};
#endif // !defined(AFX_BINARYTREE_H__61FEB349_65EE_40FB_82DF_25FFBCBDFC6E__INCLUDED_)
BinaryTreecpp
// BinaryTreecpp: implementation of the BinaryTree class
//
//////////////////////////////////////////////////////////////////////
#include "BinaryTreeh"
#include<stdlibh>
#include "queueh"
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
void BinaryTree::CreateBinTree(BinTreeNode &subTree) /////////建立二叉树
{
T item;
cin>>item;
if(item!=RefValue)
{
subTree=new BinTreeNode(item);
if(subTree==NULL)
{
cerr<<"存储分配错误！"<<endl;
exit(1);
}
CreateBinTree(subTree->leftChild);
CreateBinTree(subTree->rightChild);
}
else subTree=NULL;
}
void BinaryTree::destroy(BinTreeNode & subTree) ////删除二叉树
{
if(subTree!=NULL)
{
destroy(subTree->leftChild);
destroy(subTree->rightChild);
delete subTree;
}
}
BinTreeNode BinaryTree::Parent(BinTreeNode subTree, BinTreeNode current) //找父母结点
{
if(subTree==NULL) return NULL;
if(subTree->leftChild==current||subTree->rightChild==current)
return subTree;
BinTreeNode p;
if((p=Parent(subTree->leftChild,current))!=NULL) return p;
else return Parent(subTree->rightChild,current);
}
void BinaryTree::preOrder( BinTreeNode &subTree) //前序遍历
{
if(subTree!=NULL)
{
cout<<subTree->data<<" ";
preOrder(subTree->leftChild);
preOrder(subTree->rightChild);
}
}
void BinaryTree::inOrder( BinTreeNode &subTree) //中序遍历
{
if(subTree!=NULL)
{
inOrder(subTree->leftChild);
cout<<subTree->data<<" ";
inOrder(subTree->rightChild);
}
}
void BinaryTree::postOrder( BinTreeNode &subTree ) // 后序遍历
{
if(subTree!=NULL)
{
postOrder(subTree->leftChild);
postOrder(subTree->rightChild);
cout<<subTree->data<<" ";
}
}
void BinaryTree::levelOrder(BinTreeNode &subtree) //层序遍历
{
if(root==NULL)return;
queue<BinTreeNode> Q;
BinTreeNode p=root;
QEnQueue(p);
while(!QIsempty())
{
QDeQueue(p);
cout<<p->data<<" ";
if(p->leftChild)
QEnQueue(p->leftChild);
if(p->rightChild)
QEnQueue(p->rightChild);
}
}
int BinaryTree::Size(BinTreeNode subTree) //求结点个数
{
if(subTree==NULL) return 0;
else return 1+Size(subTree->leftChild)+Size(subTree->rightChild);
}
int BinaryTree::Height(BinTreeNode subTree) //求数的深度
{
if(subTree==NULL) return 0;
else
{
int i=Height(subTree->leftChild);
int j=Height(subTree->rightChild);
return (i>j)i+1:j+1;
}
}
int BinaryTree::leaves(BinTreeNode &subTree) //求叶子节点个数
{
if(subTree==NULL) return 0;
else if(subTree->leftChild==NULL&&subTree->rightChild==NULL)return 1;
else
{
int i=leaves(subTree->leftChild);
int j=leaves(subTree->rightChild);
return i+j;
}
}
主函数：
#include "BinaryTreeh"
int main_menu()
{
char option;
while(1)
{
cout<<" 主菜单"<<endl;
cout<<endl;
cout<<" 请选择 *** 作:"<<endl;
cout<<" 1 建立树:"<<endl;
cout<<" 2 清空树"<<endl;
cout<<" 3 退出"<<endl;
cin>>option;
switch(option)
{
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
default:
cout<<"输入错误，请检查输入!"<<endl;
break;
}
}
}
int tree_menu(BinaryTree &btn)
{
char option;
while(1)
{
cout<<" 树的相关 *** 作:"<<endl;
cout<<" 请选择 *** 作:"<<endl;
//cout<<" 1 输入节点"<<endl;
cout<<" 2 按前序输出"<<endl;
cout<<" 3 按中序输出"<<endl;
cout<<" 4 按后序输出"<<endl;
cout<<" 5 按层序输出"<<endl;
cout<<" 6 求节点个数"<<endl;
cout<<" 7 求树的深度"<<endl;
cout<<" 8 求树的高度"<<endl;
cout<<" 9 返回主菜单"<<endl;
cin>>option;
switch(option)
{
// case '1':
// {
// cout<<"输入节点,-1为结束标志"<<endl;
// btnCreateBinTree();
// break;
// }
case '2':
{
cout<<"按前序输出为:"<<endl;
btnpreOrder();
break;
}
case '3':
{
cout<<"按中序输出为:"<<endl;
btninOrder();
break;
}
case '4':
{
cout<<"按后序输出为:"<<endl;
btnpostOrder();
break;
}
case '5':
{
cout<<"按层序输出为:"<<endl;
btnlevelOrder();
break;
}
case '6':
{
cout<<"节点个数为:"<<btnSize()<<endl;
break;
}
case '7':
{
cout<<"求树的深度为:"<<btnHeight()<<endl;
break;
}
case '8':
{
cout<<"求树的高度为:"<<btnHeight()<<endl;
break;
}
case '9':
return 9;
default:
cout<<"输入有误，请检查输入!"<<endl;
break;
}
}
}
int main()
{
bool bCreated=false;
int op;
BinaryTree btn(-1);
while(1)
{
op=main_menu();
switch(op)
{
case 1:
{
if(!bCreated)
{
cout<<"1 输入节点,-1为结束标志"<<endl;
btnCreateBinTree();
}
bCreated=true;
tree_menu(btn);
break;
}
case 2:
{
btndestroy();
bCreated=false;
break;
}
case 3:
return 0;
}
}
return 0;
}
你说的是一个窗体的所有控件吗？那你可以加一个panel，我们命名为panel1，然后输出每一个子窗体的名字。
代码如下：
for (int i = 0; i < panel1ControlsCount; i++)
{
MessageBoxShow(panel1Controls[i]Name);
}
如果是遍历窗体的话如下
public void TraverseForm()
{
Assembly a = AssemblyLoadFile(ApplicationExecutablePath);//net中的反射
Type[] types = aGetTypes();
foreach (Type t in types)
{
if (tBaseTypeName == "Form")
{
Form f = (Form)ActivatorCreateInstance(t, true);
if (f != null)
{
// 此为创建该窗体实例以后的逻辑
}
}
}
}
用Ctrl+F查找指定的代码，在标准工具条末尾有显示找到数据的行列信息；
如果你非要以VBA代码来查，那就将代码另存为TXT文件，用VBA打开TXT文件的逐行比较方式查找需要的信息，不过似乎没必要这样做，因为代码查找窗口的选项（当前过程、当前模块、当前工程）应该能满足你的需要了。
同行规定列之间遍历
说说 这个具体是怎么 个 遍历 法？能举几个例子吗？你要返回什么内容……
使用 查找类 的函数 就可以在 一个区域内 遍历（有时也不能保证 完全 遍历到 它会遇到符合条件的就停止）具体情况具体分析……
删掉前两行
dsTables[0]RowsRemoveAt(0);//删除第一行
dsTables[0]RowsRemoveAt(0);//原第二行变成了第一行，所以在此删除第一行
然后绑定就行了
Assembly assembly = typeof("当前程序集名称")Assembly;
//或
Assembly assembly = AssemblyGetExecutingAssembly();//当前程序集
foreach (Type type in assemblyGetTypes())
{
ConsoleWriteLine(typeFullName);
//if(typeFullNameEndsWith(Student))
ConsoleWriteLine("found");
}
以上就是关于C语言的遍历算法全部的内容，包括:C语言的遍历算法、我们数据结构实验课让用C++做一个二叉树的遍历的程序，老师也没讲过具体怎么弄，求高手解答！、C#如何遍历程应用程序中的所有窗体等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）