Este artículo hace referencia a la "Estructura de datos de Dahua", gracias al autor, el Sr. Cheng Jie.
Uno: la
supuesta ventaja es pensar más profundamente que los demás.
Dos:
Las ventajas del árbol de ordenación binaria:
* La eficiencia de inserción y eliminación y la eficiencia de implementación de búsqueda de elementos son muy altas, y la complejidad de tiempo es O (logN);
Tres:
La creación de un árbol de ordenamiento binario:
cuando necesitamos buscar el conjunto {62, 88, 58, 47, 35, 73, 51, 99, 37, 93},
debemos considerar la estructura del árbol binario al crear este Y el árbol binario que se ordena en el tiempo:
Cuatro:
árbol de ordenación binaria, también conocido como árbol de búsqueda binaria.
Es un árbol vacío o un árbol binario con las siguientes propiedades:
1. Si su subárbol izquierdo no está vacío, los valores de todos los nodos en el subárbol izquierdo son menores que el valor de su estructura raíz;
2. Si su el subárbol derecho no está vacío, entonces los valores de todos los nodos en el subárbol derecho son mayores que el valor de su estructura raíz
3. Sus subárboles izquierdo y derecho también son árboles ordenados binariamente, respectivamente;
Cinco: Resumen:
1. El árbol de clasificación binaria se almacena de manera vinculada, manteniendo la ventaja de que la estructura de almacenamiento vinculada
no necesita mover elementos al insertar y eliminar operaciones . Siempre que se encuentren las posiciones de inserción y eliminación adecuadas, solo es necesario modificar el puntero de conexión.
2. El rendimiento temporal de la inserción y la eliminación es mejor, y para la búsqueda del árbol de clasificación binaria, se toma la ruta desde el nodo raíz al nodo que
se va a encontrar y el número de comparaciones es igual al número de capas del binario. árbol de clasificación en el árbol de clasificación binaria.
Seis: Código de implementación:
/*
本篇文章参考的是《大话数据结构》，感谢作者程杰先生。
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include "bigtalk_data_structure.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 100 /* 存储空间初始分配量 */
typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
/* 二叉树的二叉链表结点结构定义 */
typedef struct BiTNode /* 结点结构 */
{
int data; /* 结点数据 */
struct BiTNode *lchild, *rchild; /* 左右孩子指针 */
} BiTNode, *BiTree;
/* 递归查找二叉排序树T中是否存在key, */
/* 指针f指向T的双亲，其初始调用值为NULL */
/* 若查找成功，则指针p指向该数据元素结点，并返回TRUE */
/* 否则指针p指向查找路径上访问的最后一个结点并返回FALSE */
Status SearchBST(BiTree T, int key, BiTree f, BiTree *p)
{
if (!T) /* 查找不成功 */
{
*p = f;
return FALSE;
}
else if (key==T->data) /* 查找成功 */
{
*p = T;
return TRUE;
}
else if (key<T->data)
{
return SearchBST(T->lchild, key, T, p); /* 在左子树中继续查找 */
}
else
{
return SearchBST(T->rchild, key, T, p); /* 在右子树中继续查找 */
}
}
/* 当二叉排序树T中不存在关键字等于key的数据元素时， */
/* 插入key并返回TRUE，否则返回FALSE */
Status InsertBST(BiTree *T, int key)
{
BiTree p,s;
if (!SearchBST(*T, key, NULL, &p)) /* 查找不成功 */
{
s = (BiTree)malloc(sizeof(BiTNode));
s->data = key;
s->lchild = s->rchild = NULL;
if (!p)
{
*T = s; /* 插入s为新的根结点 */
}
else if (key<p->data)
{
p->lchild = s; /* 插入s为左孩子 */
}
else
{
p->rchild = s; /* 插入s为右孩子 */
}
return TRUE;
}
else
{
return FALSE; /* 树中已有关键字相同的结点，不再插入 */
}
}
/* 从二叉排序树中删除结点p，并重接它的左或右子树。 */
Status Delete(BiTree *p)
{
BiTree q,s;
if((*p)->rchild == NULL) /* 右子树空则只需重接它的左子树（待删结点是叶子也走此分支) */
{
q = *p;
*p = (*p)->lchild;
free(q);
}
else if((*p)->lchild == NULL) /* 只需重接它的右子树 */
{
q = *p;
*p = (*p)->rchild;
free(q);
}
else /* 左右子树均不空 */
{
q = *p;
s = (*p)->lchild;
while(s->rchild) /* 转左，然后向右到尽头（找待删结点的前驱） */
{
q = s;
s = s->rchild;
}
(*p)->data = s->data; /* s指向被删结点的直接前驱（将被删结点前驱的值取代被删结点的值） */
if(q != *p)
{
q->rchild = s->lchild; /* 重接q的右子树 */
}
else
{
q->lchild = s->lchild; /* 重接q的左子树 */
}
free(s);
}
return TRUE;
}
/* 若二叉排序树T中存在关键字等于key的数据元素时，则删除该数据元素结点, */
/* 并返回TRUE；否则返回FALSE。 */
Status DeleteBST(BiTree *T,int key)
{
if(!*T) /* 不存在关键字等于key的数据元素 */
{
return FALSE;
}
else
{
if (key == (*T)->data) /* 找到关键字等于key的数据元素 */
{
return Delete(T);
}
else if (key<(*T)->data)
{
return DeleteBST(&(*T)->lchild,key);
}
else
{
return DeleteBST(&(*T)->rchild,key);
}
}
}
//中序遍历二叉树
Status RecursionBST(BiTree *T)
{
if(!*T) /* 不存在关键字等于key的数据元素 */
{
return FALSE;
}
RecursionBST(&(*T)->lchild);
//printf("[%s:%d]:[yang](*T)->data = %d\n",__FUNCTION__,__LINE__,(*T)->data);
printf("%d, ",(*T)->data);
RecursionBST(&(*T)->rchild);
return TRUE;
}
//二叉排序树:
int test_main_8_6()
{
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
int i;
int a[10]={
62,88,58,47,35,73,51,99,37,93};
BiTree T = NULL;
for(i = 0; i < 10; i++)
{
InsertBST(&T, a[i]);
printf("i+1 = %d: ", i + 1);
RecursionBST(&T);
printf("\n");
}
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
RecursionBST(&T);
printf("\n");
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
DeleteBST(&T,93);
RecursionBST(&T);
printf("\n");
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
DeleteBST(&T,47);
RecursionBST(&T);
printf("\n");
#if 0
#endif
printf("[%s:%d]:[yang] ******************* 我是分割线******************* \n",__FUNCTION__,__LINE__);
return 0;
}
impresión:
[main:14]:[yang] *****************************************
[test_main_8_6:183]:[yang] ******************* 我是分割线*******************
i+1 = 1: 62,
i+1 = 2: 62, 88,
i+1 = 3: 58, 62, 88,
i+1 = 4: 47, 58, 62, 88,
i+1 = 5: 35, 47, 58, 62, 88,
i+1 = 6: 35, 47, 58, 62, 73, 88,
i+1 = 7: 35, 47, 51, 58, 62, 73, 88,
i+1 = 8: 35, 47, 51, 58, 62, 73, 88, 99,
i+1 = 9: 35, 37, 47, 51, 58, 62, 73, 88, 99,
i+1 = 10: 35, 37, 47, 51, 58, 62, 73, 88, 93, 99,
[test_main_8_6:197]:[yang] ******************* 我是分割线*******************
35, 37, 47, 51, 58, 62, 73, 88, 93, 99,
[test_main_8_6:202]:[yang] ******************* 我是分割线*******************
35, 37, 47, 51, 58, 62, 73, 88, 99,
[test_main_8_6:208]:[yang] ******************* 我是分割线*******************
35, 37, 51, 58, 62, 73, 88, 99,
[test_main_8_6:219]:[yang] ******************* 我是分割线*******************