Technology sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. conceptus et structura ligno

1.1 De conceptu arboreo

lignum est anonlinear Data structura, quae est ordo relationum hierarchicarum ex n (n>=0) compositarum nodi limitatorum.FasciculusDicitur arbor, quia apparet sicut arbor inversi, quod significat radices sursum et folia monstrantia.

• Radix nodi: Radix nodi nodus praedecessoris non habet.
• Praeter nodi radicem, reliqui nodi in subtres dividuntur structura simili cum arbore. Nodus radicis uniuscuiusque subtrei unum et unicum praedecessorem habet, et 0 vel plures successores habere potest.
• Ergo arbor estrecursive definitionof.

1.2 notiones de arboribus Related

• Gradus nodiNumerus subtrium in nodo comprehensus gradus nodi appellatur
• Folium nodi seu terminalis nodiNodi cum gradu 0 vocantur nodi folium;
• Non-terminatio nodi seu genere nodiNodi, quorum gradus non est 0;
• Parens nodi seu parens nodi: Si nodi infantis nodos contineat, hic nodi dicitur nodi prolis parentis sui
• puer nodi vel pueri nodi: Nodus radicis subtree nodo comprehensus, dicitur puer nodi nodis;
• Nodi fratrem: Nodi cum eodem parente nodi vocantur nodi germani, ut supra ostensum est.
• gradus arborisIn arbore gradus maximae nodi gradus arboris dicitur;
• Node graduIncipiens a definitione radicis, radix est gradus 1, nodi radicis proles sunt 2 gradus, et sic de aliis;
• altitudo altitudinem arboris: Nodorum planities maxima in arbore, ut supra ostensum est. Arbor altitudo 3
• cognatus nodiNodi, quorum parentes in eodem gradu sunt inter se consobrinos;
• Pater nodi: Nodi omnes in ramis ab radice usque ad nodi;
• posteri : Nodus quelibet in subtrea quadam nodi radicata dicitur illius nodi proles.Ut supra ostensum est: omnes nodi posteri sunt A .
• silvaCollectio m disiunctis arboribus silva dicitur;

1.3 arbor repraesentatio

Structura ligni magis complicata quam mensae linearis, et molestius condere ac repraesentare.Necesse est ut tam valoris ambitus quam relatio inter nodi et nodos servetur.re vera multae viae ad repraesentandum arbores, ut;Parentis notatio, puer notatio, puer notatio parens et puer frater notatiomanere.

In processu introducendi sequentem structuram repositionis, exemplum sequentis arboris accipimus.

1.3.1 parens representation

Ponamus nodos arboris in stato spatiorum continuorum et simul repositorumIn unaquaque nodo index adnectitur ad indicandam positionem nodi parentis sui in indice coniuncto. . Id est, praeter scire quis sit, nodus quisque etiam novit ubi sunt parentes ejus.

Inter eos, notitia campi notitia, quae notitias nodi addit. Et parens campus monstrator est qui subscripta nodo parentes in acie reponit.
Sequens est structura nodi definitio codicis pro parente nostro repraesentatio.

/*树的双亲表示法结点结构定义*/
#define MAX_TREE_SIZE 100
typedef int TElemType;	//树结点的数据类型，目前暂定为整型
/*结点结构*/
typedef struct TreeNode
{
	TElemType data;	//结点数据
	int parent;	//双亲位置
}TreeNode;
/*树结构*/
typedef struct
{
	TreeNode nodes[MAX_TREE_SIZE];	//结点数组
	int r, n;	//根的位置和结点数
}PTree;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Cum tali structurae repositione, facile possumus nodos parentis eius invenire secundum regulam parentis nodiTempus complexionem 0 (I) donec parens -1 sit, radicem arboris nodi inventam significans. Sed si scire velimus quid filii nodi sint, doleo, quaeso, totam structuram percurrere.

1.3.2 Fili frater representation

Modo studuimus structuram repositam arboris e prospectu parentum et prospectum pueri Fratres Nodorum. Non est possibile. Post considerationem, invenimus quod in qualibet arbore, primus filius nodi est singularis si existit, et frater eius ius est etiam unicus si est. Ponimus ergo duas regulas demonstrantes primo prolem nodi et dextrum nodi fratrem.

/*树的孩子兄弟表示法结构定义*/
typedef struct TreeNode
{
	TElemtype data;
	struct TreeNode *firstchild, *rightsib;
} TreeNode,* pTreeNode;
1
2
3
4
5
6

1.4 De applicationibus arborum

2. conceptus et structura ligni binarii

2.1 Conceptus

Binaria arbor est nodorum finita, quae est;

• aut vacua
• Constat nodi radicis plus duabus arboribus binariis, quae etiam laeva subtree et dextra subtree sunt.

Ut videri potest ex pictura supra;

1. Nulla nodi cum gradu maior quam 2 in ligno binario
2. Subtres arboris binariae dividi possunt in subtrees dextra et dextra, et ordo inverti non potest, sic arbor binaria.iussi ligno

Nota: Quaelibet arbor binaria componitur ex his adiunctis;

2.2 Praecipua ligna binaria

1. plena lignum binariiarbor binaria;Si numerus nodis in unoquoque tabulato maximam attingit, arbor binaria est plena arbor binaria. . Hoc est, si numerus graduum arboris binarii est K, et numerus nodorum est 2^k-1, tunc est plena arbor binaria.
2. integram binarii ligno: Plena arbor binaria est efficax notitiarum structura.Complete binae arbores ex plena arboribus binariis . Nam arbor binaria cum profundis K et n nodis, dicitur arbor binaria completa, si et solum si unumquodque nodi correspondet uni cum nodis ab 1 ad n in plena arbore binaria cum profunditate K. Ad custodiendumArbor plena binaria est species arboris binariae completae.
   

2.3 proprietatibus arborum binarii

1. Si numerus gradus nodi radicis specificetur esse 1, tunc eritSunt in summa II ^ (i-I) in i-th tabulatum lymphaticorum
2. Si numerus gradus nodi radicis specificetur esse I, deindeMaximus numerus nodis binarii arboris cum altitudine h est II ^ h-1
3. Pro qualibet arbore binaria, siNumerus nodi foliorum cum gradu 0 est n0, et numerus nodi ramorum cum gradu 2 est n2, deinde n0=n2 +1.
4. Si numerus gradus nodi radicis specificetur esse I;Altitudo ligni binarii plenae cum n nodis, h=log (n+1) (Ps: stipes est basis II, n + I est logarithmus)
5. Ad arborem binariam integram cum nodis n, si omnes nodi numerantur ab 0 incipiendo ordine ordinato a summo ad imum, sinistrorsum ad dextrum, tum ad nodi cum i.
   • Si i>0, numerus parentis nodi in positione i: (i-1)/2;, i est numerus nodi radicis, nullus parens nodi
   • Si 2i + 1, 2i+1>=n aliter non est puer relictus
   • Si 2i+2, 2i+2>=n aliter non est puer rectus

2.4 at structuram ligni binarii

Arbores binarii plerumque recondi possunt duabus structuris utentes;Sequentia compages, catenae structura.

1. sequentem repono
   Sequential structuram repono est utiordinataCondere, plerumque uti aciemApta tantum repraesentans arbores integras binarias quia non est tota arbor binaria nec erit vastitas spatii. Reapse solus acervus vestit utitur ad repono.Tabularium sequentium arborum binarii physice est ordinata et logice arbor binaria.
   2. Catena repono
   Connexa structura arboris binarii significat;Utere coniunctum album repraesentare binarii ligno , id est per vincula ad indicandam logicam elementorum habitudinem. Usitatius modus est, quod uterque nodi in indice coniuncto constat ex tribus agris, campus notitia et dextra monstratorem agrorum. Sinistra et dextra monstratores ad inscriptiones repositas dare connexionis punctorum ubi puer sinister et pueri recti nodi respective collocantur. Catenae structurae in binarias catenulas dividuntur et catenis trifurcatis. In statu, catenis binariis plerumque student.
   

3. Sequentialis structura et exsecutio ligni binarii

Ordinariae arbores binariae non sunt aptae ad reponendum in vestitu, quia multum spatii vastati esse possunt.etPlenae arbores binariae aptiores sunt ad structuram sequentialem repositionis .Reapse solemusTumulus (arbor binaria) sequentiae structurae acie utitur ad reponuntnotandum est acervus hic et acervus in processu virtuali electronici spatii systematis operantis duo diversa sunt.
Ad specifica exsecutionem et applicationem, quaeso vide:[Data Structure] 08. Cumulo et cumulo applicationes

4. Catena structura ligni binarii et ejus exsecutio

4.1 Binarii arbor traversal

Via simplicissima structuram ligni binarii discendi est percurrere.dictusLignum binarium traversale (Traversal) est operationes nodis in arbore binaria in ordine secundum certas regulas respondentes fungi, et uterque nodi semel tantum operatus est. . Operationes per nodos accessiones factae secundum problema applicationis specificae pendent. Traversal una ex maximis operationibus in arbore binaria est etiam fundamentum aliarum operationum in arbore binaria.

4.1.1 Preorder traversal

//根 左子树 右子树
void PrevOrder(pTreeNode root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	printf("%d ", root->val);
	PrevOrder(root->left);
	PrevOrder(root->right);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Figura infra ostendit processum recursivum;

4.1.2 in ordinem traversal

//左子树 根 右子树
void InOrder(pTreeNode root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->val);
	InOrder(root->right);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Hic processus recursivus est:

4.1.3 Postorder traversal

//左子树 右子树 根
void PostOrder(pTreeNode root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->val);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

Hic processus recursivus est:

4.2.4 Level-ordo traversal

Ordo traversalis: Praeter ordinem traversalem, in ordinem traversalem, et post ordinem traversalem, ordo traversalis etiam in arboribus binariis fieri potest. Pone gradum nodi radicis arboris binarii numerus est 1. Gradus ordo traversalis incipit a nodo radicis arboris binarii planities a sinistro ad dextrum, et dein tertia;Processus visitandi nodos ligni iacuit a summo ad imum et a sinistro ad dextrum iacuit ordo traversus est.。
Illustratio:

Hic intercedit in queue ad praecellens ordinem traversalis arboris binariae faciendae.

// 层序遍历
void LevelOrder(pTreeNode root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		pTreeNode front = QueueFront(&q);
		QueuePop(&q);
		if (front == NULL)
		{
			printf("NULL ");
		}
		else
		{
			printf("%d ", front->val);
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
	}
	QueueDestory(&q);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

4.1 Creatio et interitus arborum binarii

Ad creare et destruere arborem binariam, utimurBinarii lignum traversalExempli gratia.

//二叉树的创建
struct TreeNode* Creat(char* arr,int n,int* i)
{ 
    if(*i<n&&arr[*i]=='#')
    {
        (*i)++;
        return NULL;
    }
    
    TreeNode* newnode=(TreeNode*)malloc(sizeof(TreeNode));
    newnode->left=NULL;
    newnode->right=NULL;

    newnode->val=arr[(*i)++];
    newnode->left=Creat(arr,n,i);
    newnode->right=Creat(arr,n,i);
    
    return newnode;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//二叉树的销毁
void TreeDestroy(struct TreeNode* root)
{
    if(root==NULL)
    {
        return;
    }
    TreeDestroy(root->left);
    TreeDestroy(root->right);
    free(root);
}
1
2
3
4
5
6
7
8
9
10
11

4.3 Aliae operationes in arboribus binariis

Hae operationes omnes per rationem traversalis exercentur.

// 二叉树节点个数
int TreeSize(pTreeNode root)
{
	if (root == NULL)
	{
		return 0;
	}
	return TreeSize(root->left) + TreeSize(root->right) + 1;
}
1
2
3
4
5
6
7
8
9

// 二叉树叶子节点个数
int TreeLeafSize(pTreeNode root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

// 二叉树第k层节点个数
int TreeLevelKSize(pTreeNode root, int k)
{
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return TreeLevelKSize(root->left, k - 1) + TreeLevelKSize(root->right, k - 1);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

// 二叉树查找值为x的节点
pTreeNode TreeFind(pTreeNode root, TreeDataType x)
{

	if (root == NULL)
	{
		return NULL;
	}
	//相等就返回
	if (root->val == x)
		return root;
	//找左子树
	pTreeNode left=TreeFind(root->left, x);
	if (left)
	{
		return left;
	}
	//找右子树
	pTreeNode right = TreeFind(root->right, x);
	if (right)
	{
		return right;
	}
	//都没找到
	return NULL;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

//二叉树的高度
int TreeHeight(pTreeNode root)
{
	if (root == NULL)
	{
		return 0;
	}
	int max_left = TreeHeight(root->left) ;
	int max_right = TreeHeight(root->right);
	return max_left > max_right ? max_left + 1 : max_right + 1;
}
1
2
3
4
5
6
7
8
9
10
11

//判断是否是完全二叉树
bool TreeComplete(pTreeNode root)
{
	Queue q;
	QueueInit(&q);
	if (root)
	{
		QueuePush(&q, root);
	}
	while (!QueueEmpty(&q))
	{
		pTreeNode front = QueueFront(&q);
		QueuePop(&q);
		if (front == NULL)
		{
			break;
		}
		else
		{
			QueuePush(&q, front->left);
			QueuePush(&q, front->right);
		}
	}
	while (!QueueEmpty(&q))
	{
		pTreeNode front = QueueFront(&q);
		QueuePop(&q);
		if (front)
		{
			QueueDestory(&q);
			return false;
		}
	}
	QueueDestory(&q);
	return true;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36