void CreateTree( int lo, int hi, int root, bool left ) {
int pivotIndex, tmpIndex;
//printf( "l:%d h:%d\n", lo, hi);
if ( lo >= hi )
return ;
for ( int i = lo; i < hi; ++i ) {
if ( inOrder[i] == postOrder[pivotCnt] ) {
pivotIndex = i;
--pivotCnt;
break;
}
}
tmpIndex = ++f**k;
tree[tmpIndex].val = inOrder[pivotIndex];
tree[tmpIndex].parentIndex = root;
if ( left )
tree[root].lChildIndex = tmpIndex;
else
tree[root].rChildIndex = tmpIndex;
CreateTree( pivotIndex + 1, hi, tmpIndex, true );
CreateTree( lo, pivotIndex, tmpIndex, false );
return ;
}
TreeNode * CreateTree(ListNode* node,int len)
{
if( len == 1)
{
TreeNode * t = new TreeNode(node->val);
t->right = t->left = NULL;
allNodes.push_back(t);
return t;
}
else
{
ListNode * cur= node;
int i = 1;
do
{
node = node->next;
}while(++i <= len/2);
TreeNode * t = new TreeNode(node->val);
t->left = CreateTree(cur,len/2);
if(len-len/2-1== 0)
t->right = NULL;
else
t->right = CreateTree(node->next,len-len/2-1);
allNodes.push_back(t);
return t;
}
}
void main()
{
int i;
PTree T,p;
TElemType e,e1;
InitTree(T);
printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",TreeEmpty(T),Root(T),TreeDepth(T));
CreateTree(T);
printf("构造树T后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",TreeEmpty(T),Root(T),TreeDepth(T));
printf("层序遍历树T:\n");
TraverseTree(T,vi);
printf("请输入待修改的结点的值 新值: ");
scanf("%c%*c%c%*c",&e,&e1);
Assign(T,e,e1);
printf("层序遍历修改后的树T:\n");
TraverseTree(T,vi);
printf("%c的双亲是%c,长子是%c,下一个兄弟是%c\n",e1,Parent(T,e1),LeftChild(T,e1),RightSibling(T,e1));
printf("建立树p:\n");
InitTree(p);
CreateTree(p);
printf("层序遍历树p:\n");
TraverseTree(p,vi);
printf("将树p插到树T中，请输入T中p的双亲结点 子树序号: ");
scanf("%c%d%*c",&e,&i);
InsertChild(T,e,i,p);
Print(T);
printf("删除树T中结点e的第i棵子树，请输入e i: ");
scanf("%c%d",&e,&i);
DeleteChild(T,e,i);
Print(T);
}
void Properties::ParseList(QTreeWidgetItem* node, const IterableT& seq) {
typename IterableT::const_iterator it, itEnd = seq.end();
int i = 0;
// skip 1 sized arrays
if (seq.size() == 0) {
// empty
if (node)
node->setData(1, Qt::DisplayRole, "<empty>");
} else if (seq.size() == 1) {
CreateTree(node, seq.first());
if (node)
node->setData(1, Qt::DisplayRole, GetSummary("[0]", seq.first()));
} else {
for (it = seq.begin(); it != itEnd; ++it) {
QTreeWidgetItem* child = new QTreeWidgetItem();
QString key = QString("[%1]").arg(i++);
child->setData(0, Qt::DisplayRole, key);
child->setData(1, Qt::DisplayRole, GetSummary(key, *it));
CreateTree(child, *it);
if (node)
node->addChild(child);
else
ui->propertyView->addTopLevelItem(child);
}
}
}
void CreateTree(Node *p) {
if (p->low_ < p->high_) {
p->left_ = new Node(p->low_, (p->low_ + p->high_) / 2);
CreateTree(p->left_);
p->right_ = new Node((p->low_ + p->high_) / 2 + 1, p->high_);
CreateTree(p->right_);
}
}
Node* CreateTree(It begin, It end) {
if (end - begin == 0) {
return nullptr;
}
Iterator middle = begin + (end - begin) / 2; // Should I be afraid of (from < to)?
Node* root = new Node(*middle);
root->left = CreateTree(begin, middle);
root->right = CreateTree(middle + 1, end);
return root;
}
SearchTree CreateTree(SearchTree T) {
int temp;
scanf("%d", &temp);
if(temp == -1)
T = NULL;
else {
T = (SearchTree)malloc(sizeof(TreeNode));
T->data = temp;
T->left = CreateTree(T->left);
T->right = CreateTree(T->right);
}
return T;
}
//先序拓展建立二叉树
void CreateTree(BiTree &T)
{
T = (BiNode*) malloc (sizeof(BiNode));
printf("Enter the data \n");
scanf("%c ",&T->data);
if(T->data == '#') T == NULL;
if(T)
{
printf("");
CreateTree(T->lch);
CreateTree(T->rch);
}
}
void MyGameTreeCtrl::RefreshTree(string* pstrPanelName)
{
m_mapNode.clear();
CreateTree();
m_bInsertData = true;
EnsureVisible(GetRootItem());
}
CreateTree(BTree &T) //必须声明为指针的指针(BTree *T)或者指针的引用 (BTree &T) 因为有 NULL指针；
{
char c;
scanf("%c",&c);
if(c ==' ')
{
T = NULL;
}
else
{
T = (BTree)malloc(sizeof(BNode));
(T)->data = c;
CreateTree((T)->lchild);
CreateTree((T)->rchild);
}
}
void COptionTreeWrapper::Serialize(CHashString objName, vector<CHashString> objTypes, IArchive &ar, bool bRead)
{
if (m_mTrees[objName.GetUniqueID()].m_Tree == NULL)
{
m_mTrees[objName.GetUniqueID()].m_Tree = new COptionTree();
m_mTrees[objName.GetUniqueID()].m_Tree->Create(m_Style, m_Rect, m_pParentWnd, m_TreeOptions, m_ID);
m_mTrees[objName.GetUniqueID()].m_Root = m_mTrees[objName.GetUniqueID()].m_Tree->InsertItem(new COptionTreeItem());
CString label;
label = objName.GetString();
label += _T("(");
label += objTypes[0].GetString();
label += _T(")");
m_mTrees[objName.GetUniqueID()].m_Root->SetLabelText(label);
for (UINT i=0; i<objTypes.size(); i++)
{
CreateTree(objTypes[i].GetString(), objName);
}
m_vRootNames.push_back(objName);
}
if (bRead)
{
SerializeIn(ar, objName);
}
else
{
SerializeOut(ar, objName);
}
ExpandOneRoot(objName);
}
void TEST_HUFMAN()
{
freopen("input.txt", "r", stdin);
int n; //需要编码的字符的个数
scanf("%d", &n);
int i;
int *wet = (int *)malloc(n * sizeof(int)); //存放每个字符的权值
for (i = 0; i<n; i++)
{
scanf("%d", wet + i);
}
HUffmanCode HC; //保存赫夫曼编码
HuffmanTree HT = CreateTree(wet, n); //生成赫夫曼树
HufmanCoding(HT, HC, n); //求每个字符的赫夫曼编码
printf("哈夫曼编码如下：\n");
for (i = 0; i<n; i++)
{
puts(HC[i]);
}
free(wet);
}
static void TreeTest (void)
{
DirEntry_s *root;
root = CreateTree(4, 9, 0);
PrintTree(root, 0);
DeleteTree(root);
}
BiTree CreateTree()
{
BiTree T;
char ch;
scanf("%c",&ch);
if(ch=='#') T=NULL;
else
{
T=(BiTree)malloc(sizeof(BiTNode));
if(!T) exit(0);
T->data=ch;
T->lchild=CreateTree();
T->rchild=CreateTree();
}
return T;
}
/*
* Collision Tree
*/
CollisionTree::CollisionTree(const sf::FloatRect & i_SubRect, const ubyte i_MaxObjects, const ubyte i_TreeDeep)
:m_TreeDeep(i_TreeDeep), m_CurrentDeep(1), m_NodeBox(i_SubRect), m_NodeCapacity(i_MaxObjects), m_IsLeaf(true)
{
m_SubNodes[0] = m_SubNodes[1] = m_SubNodes[2] = m_SubNodes[3] = nullptr;
// Create the tree
CreateTree();
}
KeyTextList* LoadKeyTextList(gchar* filename)
{
KeyTextList* list;
gchar* pathname = NULL;
if( !g_keytext_dir || !filename )
return NULL;
if( (pathname = CheckFileExists(g_keytext_dir, filename)) == NULL )
if( (pathname = CheckFileExists("keytext", filename)) == NULL )
return NULL;
list = (KeyTextList*)g_malloc(sizeof(KeyTextList));
if( list != NULL )
{
if( (list->tree = CreateTree()) != NULL )
{
if( ReadXMLFile(pathname, list->tree) )
{
return list;
}
FreeTree(list->tree);
}
g_free(list);
}
return NULL;
}
short LoadKeyTextList( void )
{
KeyTextList* list;
char* pathname = NULL;
short result = -1;
if( !g_keytext_dir ) goto Err1;
if( (pathname = CheckFileExists(g_keytext_dir, CNIJLGMON2_RESFILE)) == NULL ){
if( (pathname = CheckFileExists("keytext", CNIJLGMON2_RESFILE)) == NULL ) goto Err1;
}
if ( (list = (KeyTextList*)malloc(sizeof(KeyTextList))) == NULL ) goto Err1;
if( (list->tree = CreateTree()) == NULL ) goto Err2;
if( ReadXMLFile(pathname, list->tree) != 0 ) goto Err3;
g_key_keytext_list = list;
result = 0;
return result;
Err3:
FreeStringList( list->tree );
Err2:
free( list );
Err1:
return result;
}
//-----------------------------------------------------------------------------
HTREEITEM CDlgLayerTree::CreateTree(CString sName, HTREEITEM hParent /*= TVI_ROOT*/)
{
HTREEITEM hReTI = m_tree.InsertItem(sName, hParent);
CStringArray strChildNameArray,strNeedArray;
if (CLayerTreeDef::GetChildrenAliasName(strChildNameArray, strNeedArray, sName))
{
for (int i = strChildNameArray.GetSize() - 1; i >= 0; i--)
{
CString Right;
CPowerConfig::GetRightByResource(strChildNameArray.GetAt(i), Right);
int nRight = atoi(Right);
if (!(nRight & POWER_SCAN))// 对比查看权限
{
//strChildNameArray.RemoveAt(i);///////////////////////////////##############################
}
}
for (int i = 0; i < strChildNameArray.GetSize(); i++)
{
HTREEITEM hTI = CreateTree(strChildNameArray.GetAt(i), hReTI);
CString sTmp = strNeedArray.GetAt(i);
if (!sTmp.IsEmpty() && sTmp.CollateNoCase("0") != 0 && hTI != NULL)
{
SetTreeCheck(hTI);
m_SdeAliasNames.Add(strChildNameArray.GetAt(i));
}
}
}
return hReTI;
}
Tree Insert(int x, Tree T)
{
if (T == NULL)
T = CreateTree(x);
else if (x < T->element)
{
T->left = Insert(x, T->left);
if (Height(T->left) - Height(T->right) == 2)
{
if (x < T->left->element)
T = SingleRotateLeft(T);
else
T = DoubleRotateLeft(T);
}
}
else if (x > T->element)
{
T->right = Insert(x, T->right);
if (Height(T->right) - Height(T->left) == 2)
{
if (x > T->right->element)
T = SingleRotateRight(T);
else
T = DoubleRotateRight(T);
}
}
T->height = (Height(T->left) > Height(T->right) ? Height(T->left) : Height(T->right)) + 1;
return T;
}
int main(int argc, char const *argv[])
{
//int err;
struct Tree *T;
char *ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
T = CreateTree(ch);
printf("递归先序遍历\n");
PreOrderTraverse(T);
printf("\n");
printf("递归中序遍历\n");
InOrderTraverse(T);
printf("\n");
printf("递归后序遍历\n");
PostOrderTraverse(T);
printf("\n");
printf("非递归先序遍历\n");
PreOrderTraverseStack(T);
printf("\n");
printf("非递归中序遍历\n");
InOrderTraverseStack(T);
printf("\n");
printf("非递归后序遍历\n");
PostOrderTraverseStack(T);
printf("\n");
return 0;
}
void HuffmanTreeTest() {
int i,n=4,m;
char test[]="DBDBDABDCDADBDADBDADACDBDBD";
char code[100],code1[100];
char alphabet[]={'A','B','C','D'};
int w[]={5,7,2,13} ;
HuffmanTree *ht;
HuffmanCode *hc;
m=2*n-1;
ht=(HuffmanTree *)malloc((m+1)*sizeof(HuffmanTree));
if(!ht) {
printf("内存分配失败！\n");
exit(0);
}
hc=(HuffmanCode *)malloc(n*sizeof(char*));
if(!hc) {
printf("内存分配失败！\n");
exit(0);
}
CreateTree(ht,n,w);
HuffmanCoding(ht,n,hc);
for(i=1;i<=n;i++)
printf("字母:%c,权重:%d,编码为 %s\n",alphabet[i-1],ht[i].weight,hc[i-1]);
Encode(hc,alphabet,test,code);
printf("\n字符串:\n%s\n转换后为:\n%s\n",test,code);
Decode(ht,n,code,alphabet,code1);
printf("\n编码:\n%s\n转换后为:\n%s\n",code,code1);
}
//------------------------------------------------------------------------------
int main(){
auto list = CreateList( std::vector<int>( {1,2,3,4,5} ) );
std::cout << PrintList( list ) << std::endl;
std::cout << PrintBackList( list ) << std::endl;
auto listA = CreateList( std::vector<int>( {1,2,3,} ) );
auto listB = CreateList( std::vector<int>( {4,5} ) );
auto ab = Append( listA, listB );
std::cout << PrintList( ab ) << std::endl;
auto tree = CreateTree( std::vector<int>( {4,2,1,3,5} ) );
std::cout << PrintTree( tree ) << std::endl;
auto treelist = TreeToList( tree );
std::cout << PrintList( treelist ) << std::endl;
TestRandomTree();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
CSTree T;
TElemType e;
TElemType e1;
InitTree(&T);
printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",\
TreeEmpty(T), Root(T), TreeDepth(T));
CreateTree(&T);
printf("构造空树后,树空否? %d(1:是 0:否) 树根为%c 树的深度为%d\n",\
TreeEmpty(T), Root(T), TreeDepth(T));
printf("先根遍历树T:\n");
PreOrderTraverse(T, vi);
printf("\n请输入等修改的结点的值 新值:");
scanf("%c%*c%c%*c", &e, &e1);
Assign(&T, e, e1);
printf("后根遍历修改后的树T:\n");
PostOrderTraverse_recurssion1(T, vi);
printf("\n");
printf("PostOrderTraverse_recurssion1 complete!\n");
PostOrderTraverse_recurssion2(T, vi);
printf("\n");
printf("PostOrderTraverse_recurssion2 complete!\n");
printf("\n%c的双亲是%c, 长子是%c,下一个兄弟是%c\n", e1, Parent(T, e1),\
LeftChild(T, e1), RightSibling(T, e1));
printf("层序遍历树:\n");
LevelOrderTraverse(T, vi);
DestroyTree(&T);
return EXIT_SUCCESS;
}
void Create(int fract)
{
switch(fract) {
case TREE:
CreateTree();
break;
}
}
int main()
{
BiTree T;
T=CreateTree();
InOrderTraverse(T);
return 0;
}
void tree_pushleft(ptree tree, ULONG type, char *data)
{
ptree _New = CreateTree();
tree->_Left = _New;
_New->_Parent = tree;
_New->data = data;
_New->type = type;
}
SpatialGraphKDNode* SpatialGraph::CreateTree(int depth, const BoundingBox& bbox, SpatialGraphKDNode* parent, int index)
{
SpatialGraphKDNode* node = new SpatialGraphKDNode(bbox, parent);
node->Tree = this;
node->bBlocked = false;
//query physics to see if we're blocked
node->bBlocked = IsBlocked( bbox );
//Calculate my index
if( parent )
{
node->Index = index;
}
else
{
node->Index = 0;
}
//Bail out if we reach max depth
depth--;
node->Depth = _depth - depth;
if (depth > 0 && node->bBlocked )
{
BoundingBox LHSbbox, RHSbbox;
MathUtil::SplitBoundingBox( bbox, (depth % 2) ? MathUtil::AA_X : MathUtil::AA_Y, LHSbbox, RHSbbox );
node->LHC = CreateTree(depth, LHSbbox, node, node->Index << 1);
node->RHC = CreateTree(depth, RHSbbox, node, (node->Index << 1) + 1);
int iMask = ~(0xFFFFFFFF << depth );
//If I have children, pad my index
node->Index = (node->Index << depth) | iMask;
//If all my children are blocked, then destroy my children
if( IsFullyBlocked(node) )
{
DeleteNode( node->LHC );
node->LHC = NULL;
DeleteNode( node->RHC );
node->RHC = NULL;
}
}
return node;
}
//---------------------------------------------------------------------------
// Class TApp
//---------------------------------------------------------------------------
void TApp::Init(){
// Uncoment one of the page manager creation procedures. Do not uncoment both
// of them.
CreateDiskPageManager(); // To create it in disk
//CreateMemoryPageManager(); // To create it in memory
// Creates the tree
CreateTree();
}//end TApp::Init
bool pawsConfigCamera::Initialize()
{
psengine->GetPSCamera()->LoadFromFile(false,false);
if (!CreateTree())
return false;
UseBorder("line");
return true;
}
int main() {
SearchTree T;
T = CreateTree(T);
// Print(T);
TreeNode* node = Find(T, 4);
printf("%d ", node->data);
printf("\n");
return 0;
}
