Estructura de cadena del árbol binario-recorrido-implementación recursiva en lenguaje C

Recorrido de preorden, orden y postorden

El recorrido del árbol binario consiste en realizar las operaciones correspondientes en los nodos del árbol binario , y cada nodo solo se opera una vez .

De acuerdo con las reglas, el recorrido del árbol binario incluye: recorrido recursivo de estructura de preorden / en orden / posorden :

1. Recorrido de pedido previo ( también conocido como recorrido de pedido previo ): la operación de acceder al nodo raíz ocurre antes de atravesar sus subárboles izquierdo y derecho.
2. Recorrido en orden (Inorder Traversal): la operación de acceder al nodo raíz ocurre durante el recorrido de sus subárboles izquierdo y derecho (en el medio).
3. Recorrido posterior al pedido : la operación de acceder al nodo raíz se produce después de atravesar sus subárboles izquierdo y derecho.

Dado que el nodo visitado debe ser la raíz de un determinado subárbol, N (Nodo ), L (Subárbol izquierdo ) y R (Subárbol derecho ) pueden interpretarse como la raíz, el subárbol izquierdo de la raíz y el subárbol derecho de la raíz . NLR , LNR y LRN también se denominan primer recorrido de raíz, recorrido de raíz media y último recorrido de raíz, respectivamente.

// 二叉树前序遍历
void PreOrder(BTNode* root);
// 二叉树中序遍历
void InOrder(BTNode* root);
// 二叉树后序遍历
void PostOrder(BTNode* root);

Diagrama de recursividad transversal de preorden :

//................................................ .El contenido conceptual anterior es todo de ciencia y tecnología de Bits.................................... ......... .........

Para comprenderlo de manera más intuitiva, primero frote un árbol binario a mano.

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


typedef int BTDataType;
typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
	BTDataType data;
}BTNode;


BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	assert(node);

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

En segundo lugar, utilizamos el orden pre/intermedio/post para acceder:

Código:

prólogo:

//前序
void PreOrder(BTNode* root){
	if (root == NULL)
	{
		printf("# ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

Orden medio:

//中序
void InOrder(BTNode* root){
	if (root == NULL)
	{
		printf("# ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

Epílogo:

//后序
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("# ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

deformación

Idea: algoritmo de divide y vencerás, divide y vencerás, convierte problemas grandes en problemas pequeños de tamaño similar. (generalmente recursivo)

1. Encuentre la cantidad de nodos del árbol binario.

Aquí hay dos métodos: ① Defina una variable global. Cada vez que recurre, la variable es ++ una vez.

② Primero encuentre la cantidad de nodos del subárbol izquierdo, agregue la cantidad de nodos del subárbol derecho y finalmente agregue la raíz. Debido a que es recursivo, se puede dividir en subárboles izquierdo y derecho hasta que encuentre un árbol NULL y ya no esté dividido. La mayoría de los siguientes ejemplos tienen esta idea.

//求二叉树结点的个数

int count = 0;
int TreeSize1(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	count++;//注：这里需要定义全局变量，因为是递归，所以不能使用局部变量

	TreeSize1(root->left);
	TreeSize1(root->right);
}

int TreeSize2(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize2(root->left) + TreeSize2(root->right) + 1;
	
	//if (root == NULL)
	//{
	//	return 0;
	//}
	//else
	//{
	//	TreeSize2(root->left) + TreeSize2(root->right) + 1;
	//}

}

2. Encuentra la cantidad de nodos de hojas.

Idea: También hay dos métodos: el primer método es crear una variable global basada en el ejemplo anterior y usar if para juzgar.

El segundo método consiste en encontrar los nodos de hoja del árbol izquierdo y del árbol derecho y luego agregarlos.

//求叶子结点的个数
int TreeLeafSize1(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	if (root->left == NULL && root->right == NULL)
	{
		count++;//定义一个全局变量
	}

	TreeLeafSize1(root->left);
	TreeLeafSize1(root->right);
	
}

//方法2
int TreeLeafSize2(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}

	return TreeLeafSize2(root->left) + TreeLeafSize2(root->right);
}

3. Encuentre el número de nodos en la k-ésima capa.

Idea: convertirlo en un subproblema y encontrar el nivel k-1 del subárbol izquierdo + el nivel k-1 del subárbol derecho

//求第k层结点的个数
int TreeKLevel(BTNode* root, int k){
	assert(k >= 1);
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	return TreeKLevel(root->left, k - 1) +
		TreeKLevel(root->right, k - 1);
}

4. Encuentra la profundidad del árbol binario.

Idea: encuentre la profundidad del árbol de la izquierda, luego encuentre la profundidad del árbol de la derecha, agregue 1 para agregar la raíz y luego compare lo siguiente, se devolverá lo que sea mayor / más profundo.

//求二叉树的深度
int TreeDepth(BTNode* root)
{
	if (root == NULL)
		return NULL;

	int leftDepth = TreeDepth(root->left)+1;
	int rightDepth = TreeDepth(root->right)+1;

	return leftDepth > rightDepth ? leftDepth  : rightDepth ;
}

5. Encuentre el valor del nodo x en el árbol binario.

Nota: Algo que vale la pena señalar aquí es la cuestión de los valores de retorno y la ruptura de la recursividad. Simplemente recorralo en preorden.

//二叉树中查找值为x结点的值
BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	BTNode* ret1 = TreeFind(root->left, x);
	if (ret1) //这里的条件是ret1不为空
		return ret1;

	BTNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

Ejercicio do: resolución de problemas en lenguaje C

1. Árbol binario de un solo valor . enlace DO

bool isUnivalTree(struct TreeNode* root){
    if(root == NULL)
         return true;
    
    if(root->left && root->left->val != root->val)
        return false;

     if(root->right && root->right->val != root->val)
          return false;
     
   return  isUnivalTree(root->left)&&
     isUnivalTree(root->right);
    //同时为true 才为true
    //一个为false 就返回false

    //根  和左孩子右孩子比较，如果不相同，就return false
    //如果相同，就继续向下看左子树，再看右子树
    //左子树继续向下划分根 左孩子 右孩子

}

2. Compruebe si los dos árboles son iguales . Enlace al DO

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if( p == NULL && q == NULL)//同时为空
          return true;
    
    if(p == NULL  ||  q == NULL)//走到这里必定有一个为空，一个不为空
          return false;

    if(p->val != q->val )
       return false;

    return  isSameTree(p->left,q->left)//左子树跟左子树比较
     && isSameTree(p->right,q->right);//右子树跟右子树比较
 
}

3. Árbol binario simétrico . Enlace al DO

bool isSymmetricSubTree(struct TreeNode* root1,struct TreeNode* root2)
{
    if(root1 == NULL && root2 == NULL)
        return true;

    if(root1 == NULL || root2 == NULL)//走到这里必定一个为空一个不为空
       return false;
    
    if(root1->val != root2->val)//必定同时不为空，比较val值
        return false;
    
    return isSymmetricSubTree(root1->left,root2->right)
    &&isSymmetricSubTree(root1->right,root2->left);
    //左树的左孩子比较右树的右孩子
    //左树的右孩子比较右树的左孩子
}

bool isSymmetric(struct TreeNode* root){
    
    if(root == NULL)
       return true;

    //以根为分割线 -- 镜像二叉树
    
    return isSymmetricSubTree(root->left,root->right);
    //根的左孩子右孩子传过去
}

4. Recorrido previo al pedido de árboles binarios . Enlace al DO

//注意：返回的值必须要放进malloc申请的数组空间里面
 //returnSize ：默认不给空间大小，也就是我们需要求出数组的大小

//首先求出malloc数组空间的大小
int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left)+TreeSize(root->right)+1;
}

//这里为什么i需要传地址，因为我们需要的是一个i 而不是栈帧空间中的每一个独立的i
//因为下面子树改变i，不会影响上面根的i，这就导致数据可能会重叠，导致后面的空间出现随机数
void prevorder(struct TreeNode* root,int* arr,int* i)
{
    if(root == NULL)
        return;

    arr[(*i)++] = root->val;

    prevorder(root->left,arr,i);
    prevorder(root->right,arr,i);

}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    
    *returnSize = TreeSize(root);

    int* arr = (int*)malloc(*returnSize * sizeof(int));

    int i = 0;//数组下标
    prevorder(root,arr,&i);
 
    return arr;

}

5. Un subárbol de otro árbol . Enlace al DO

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if( p == NULL && q == NULL)//同时为空
          return true;
    
    if(p == NULL  ||  q == NULL)//走到这里必定有一个为空，一个不为空
          return false;

    if(p->val != q->val )
       return false;

    return  isSameTree(p->left,q->left)//左子树跟左子树比较
     && isSameTree(p->right,q->right);//右子树跟右子树比较
 
}

 //思路：把原树中的所有子树都找出来与subRoot进行比较
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){

   if(root == NULL)
      return false;


    //遍历所有子树进行比较 ，subroot与root所有的根节点进行比较
    if(isSameTree(root,subRoot))
        return true;
   
    //角度2.
    //先与当前树进行比较，如果不是当前树的子树
    //那么就去与当前树的左子树进行比较
    //如果也不是
    //就与当前树的右子树进行比较
    //只要有一个为true 就可以，所有这里是或|| 
    return isSubtree(root->left,subRoot)
            || isSubtree(root->right,subRoot);

}

6. Construcción y recorrido de árboles binarios . Enlace al DO

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


typedef char BTDataType;
typedef struct BinaryTreeNode {
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
    BTDataType data;
} BTNode;


BTNode* BuyNode(BTDataType x) {
    BTNode* node = (BTNode*)malloc(sizeof(BTNode));
    assert(node);

    node->data = x;
    node->left = NULL;
    node->right = NULL;

    return node;
}

BTNode* CreateTree(char* arr,int* i)//前序构建
{
    if(arr[*i] == '#')
    {
        (*i)++;
        return NULL;
    }

    BTNode* root = BuyNode(arr[(*i)++] );

    root->left = CreateTree(arr,i);//先构建左子树
    root->right = CreateTree(arr,i);//再构建右子树

    return root;//返回根节点
}

//中序遍历
void Inorder(BTNode* root)
{
    if(root == NULL)
        return ;

    Inorder(root->left);
    printf("%c ",root->data);
    Inorder(root->right);

}

int main()
{
    char arr[100]={0};
    scanf("%s",arr);

    int i=0;//数组下标
    BTNode* root = CreateTree(arr,&i);
    Inorder(root);

    return 0;
}

Lo anterior es solo para referencia.

Estructura de cadena del árbol binario-recorrido-implementación recursiva en lenguaje C

Supongo que te gusta