Glib学习（9） 平衡二叉树 Balanced Binary Trees

水深无声 2022-07-24 07:15 217阅读 0赞

平衡二叉树（Balanced Binary Tree）又被称为AVL树

且具有以下性质：

它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

构造与调整方法 平衡二叉树的常用算法有红黑树、AVL、Treap等。

最小二叉平衡树的节点的公式如下 F(n)=F(n-1)+F(n-2)+1 这个类似于一个递归的数列，可以参考Fibonacci数列，1是根节点，F(n-1)是左子树的节点数量，F(n-2)是右子树的节点数量。

AVL树是最先发明的自平衡二叉查找算法，是平衡二叉树的一种。在AVL中任何节点的两个儿子子树的高度最大差别为1，所以它又被成为高度平衡树。查找、插入和删除在平均和最坏情况下都是O(log n)。增加和删除可能需要通过一次或多次树旋转来平衡这棵树。

总的来说平衡二叉树是一种存储结构，这种存储结构会提高遍历和查找的效率，所以今天讲的数据结构是用来存储数据，并且目的是提高查找效率的，作用有点像哈希表。

先来说明文档网址：http://web.mit.edu/barnowl/share/gtk-doc/html/glib/glib-Balanced-Binary-Trees.html

这里需要注意的是我在编译的程序的时候使用的是2.0.6版本，而这个帮助文档的版本是2.16.3，其中g_tree_remove函数的返回值类型不同。

这个数据结构体：

GTree

  1. typedef struct _GTree GTree;

功能函数：

Synopsis

  1. #include <glib.h>
  4.                     GTree;
  5. GTree*              g_tree_new                          (GCompareFunc key_compare_func);
  6. GTree*              g_tree_new_with_data                (GCompareDataFunc key_compare_func,
  7.                                                          gpointer key_compare_data);
  8. GTree*              g_tree_new_full                     (GCompareDataFunc key_compare_func,
  9.                                                          gpointer key_compare_data,
  10.                                                          GDestroyNotify key_destroy_func,
  11.                                                          GDestroyNotify value_destroy_func);
  12. void                g_tree_insert                       (GTree *tree,
  13.                                                          gpointer key,
  14.                                                          gpointer value);
  15. void                g_tree_replace                      (GTree *tree,
  16.                                                          gpointer key,
  17.                                                          gpointer value);
  18. gint                g_tree_nnodes                       (GTree *tree);
  19. gint                g_tree_height                       (GTree *tree);
  20. gpointer            g_tree_lookup                       (GTree *tree,
  21.                                                          gconstpointer key);
  22. gboolean            g_tree_lookup_extended              (GTree *tree,
  23.                                                          gconstpointer lookup_key,
  24.                                                          gpointer *orig_key,
  25.                                                          gpointer *value);
  26. void                g_tree_foreach                      (GTree *tree,
  27.                                                          GTraverseFunc func,
  28.                                                          gpointer user_data);
  29. void                g_tree_traverse                     (GTree *tree,
  30.                                                          GTraverseFunc traverse_func,
  31.                                                          GTraverseType traverse_type,
  32.                                                          gpointer user_data);
  33. gboolean            (*GTraverseFunc)                    (gpointer key,
  34.                                                          gpointer value,
  35.                                                          gpointer data);
  36. enum                GTraverseType;
  37. gpointer            g_tree_search                       (GTree *tree,
  38.                                                          GCompareFunc search_func,
  39.                                                          gconstpointer user_data);
  40. gboolean            g_tree_remove                       (GTree *tree,
  41.                                                          gconstpointer key);
  42. gboolean            g_tree_steal                        (GTree *tree,
  43.                                                          gconstpointer key);
  44. void                g_tree_destroy                      (GTree *tree);

下面先看一小段代码：

  1. #include <glib.h>
  3. struct map {
  4.     int key;
  5.     char *value;
  6. } m[10] = {
  7.     {0,"zero"},
  8.     {1,"one"},
  9.     {2,"two"},
  10.     {3,"three"},
  11.     {4,"four"},
  12.     {5,"five"},
  13.     {6,"six"},
  14.     {7,"seven"},
  15.     {8,"eight"},
  16.     {9,"nine"},
  17. };
  18. typedef struct map map;
  20. static gint
  21. myCompare(gconstpointer p1, gconstpointer p2)
  22. {
  23.     const char *a = p1;
  24.     const char *b = p2;
  26.     return *a - *b;
  27. }
  29. static gint
  30. mySearch(gconstpointer p1, gconstpointer p2)
  31. {
  32.     return myCompare(p1, p2);
  33. }
  35. static gint
  36. myTraverse(gpointer key, gpointer value, gpointer fmt)
  37. {
  38.     g_printf(fmt, *(gint*)key, (gchar*)value);
  40.     return FALSE;
  41. }
  43. static void
  44. test_avl_tree(void)
  45. {
  46.     GTree *tree;
  47.     gint i;
  49. // GTree* g_tree_new(GCompareFunc key_compare_func);    用来创建一个平衡二叉树，key_compare_func函数用来排序节点规则
  50.     tree = g_tree_new(myCompare);
  52. // void g_tree_insert(GTree *tree, gpointer key, gpointer value);   插入一个键值到树中
  53. // 需要注意的是如果key值重复的话会将以前的值进行去除然后将新的键值加入树中，去除的包括key值
  54. // 如果使用的是new_full函数并且实现了销毁key和value的函数，在插入重复key时会新的key被销毁
  55.     for (i = 0; i < sizeof(m)/sizeof(m[0]); i++)
  56.         g_tree_insert(tree, &m[i].key, m[i].value);
  58. // void g_tree_foreach(GTree *tree, GTraverseFunc func, gpointer user_data);    遍历树，将键值依次传入func函数中
  59.     g_printf("Now the tree:\n");
  60.     g_tree_foreach(tree, myTraverse, "Key:\t%d\t\tVaule:\t%s\n");
  61. // gint g_tree_nnodes(GTree *tree);     取得树中的节点数
  62.     g_printf("The tree should have '%d' items now.\t\tResult: %d.\n", 10, g_tree_nnodes(tree));
  63. // gint g_tree_height(GTree *tree);     取得树的高度，如果是空树将返回0，如果只有根节点返回1，以此类推
  64.     g_printf("The height of tree is '%d' now.\n", g_tree_height(tree));
  66. // void g_tree_replace(GTree *tree, gpointer key, gpointer value);  将key的值用value替换，功能和g_tree_insert很相似，只是在销毁的时候会去销毁旧的key，而不是新的
  67.     g_tree_replace(tree, &m[3].key, "3333");
  68.     g_printf("Now the vaule of '%d' should be '3333' now.\n", m[3].key);
  69.     g_tree_foreach(tree, myTraverse, "Key:\t%d\t\tVaule:\t%s\n");
  71.     gchar *tmp = NULL;
  72. // gpointer g_tree_lookup(GTree *tree, gconstpointer key);  查找key的值
  73.     g_printf("Now the vaule of '%d' should be '%s' now[lookup].\n", m[3].key, (tmp = (gchar *)g_tree_lookup(tree, &m[3].key)) != NULL ? tmp : NULL);
  75. // gboolean g_tree_remove(GTree *tree, gconstpointer key);  移除key对应的键值，需要注意的是在2.0版本中这个函数返回类型是void，在之后的版本中返回是bool，代表是否成功
  76. //    gboolean b = g_tree_remove(tree, &m[3].key);
  77.     g_tree_remove(tree, &m[3].key);
  78.     g_printf("The key '%d' has been found and removed now.\n", m[3].key);
  80. // gpointer g_tree_search(GTree *tree, GCompareFunc search_func, gconstpointer user_data);  通过search_func形式去查找树，可以使用这种方式暂时改变查找方式，比如正序或倒序
  81.     g_printf("Now the vaule which should be removed of '%d' should be '%s' now[search].\n", 
  82.             m[3].key, 
  83.             (tmp = (gchar *)g_tree_search(tree, mySearch, &m[3].key)) != NULL ? tmp : NULL);
  85.     g_printf("Now the tree look like:\n");
  86.     g_tree_foreach(tree, myTraverse, "Key:\t%d\t\tVaule:\t%s\n");
  88. // void g_tree_destroy(GTree *tree);释放树，如果使用g_tree_new_full()函数创建的树会使用销毁函数同时销毁键值
  89.     g_tree_destroy(tree);
  90. }
  92. int
  93. main(void)
  94. {
  95.     g_printf("BEGIN:\n************************************************************\n");
  97.     test_avl_tree();
  99.     g_printf("\n************************************************************\nDONE\n");
  101.     return 0;
  102. }

在程序中保存了一个map表，其中是int型的key和字符串类型的value。

看一下运行结果：

  1. linux@ubuntu:~/16021/glibDemo$ gcc GTree.c -o GTree -lglib-2.0
  2. linux@ubuntu:~/16021/glibDemo$ ./GTree
  3. BEGIN:
  4. ************************************************************
  5. Now the tree:
  6. Key:    0        Vaule:    zero
  7. Key:    1        Vaule:    one
  8. Key:    2        Vaule:    two
  9. Key:    3        Vaule:    three
  10. Key:    4        Vaule:    four
  11. Key:    5        Vaule:    five
  12. Key:    6        Vaule:    six
  13. Key:    7        Vaule:    seven
  14. Key:    8        Vaule:    eight
  15. Key:    9        Vaule:    nine
  16. The tree should have '10' items now.        Result: 10.
  17. The height of tree is '4' now.
  18. Now the vaule of '3' should be '3333' now.
  19. Key:    0        Vaule:    zero
  20. Key:    1        Vaule:    one
  21. Key:    2        Vaule:    two
  22. Key:    3        Vaule:    3333
  23. Key:    4        Vaule:    four
  24. Key:    5        Vaule:    five
  25. Key:    6        Vaule:    six
  26. Key:    7        Vaule:    seven
  27. Key:    8        Vaule:    eight
  28. Key:    9        Vaule:    nine
  29. Now the vaule of '3' should be '3333' now[lookup].
  30. The key '3' has been found and removed now.
  31. Now the vaule which should be removed of '3' should be '(null)' now[search].
  32. Now the tree look like:
  33. Key:    0        Vaule:    zero
  34. Key:    1        Vaule:    one
  35. Key:    2        Vaule:    two
  36. Key:    4        Vaule:    four
  37. Key:    5        Vaule:    five
  38. Key:    6        Vaule:    six
  39. Key:    7        Vaule:    seven
  40. Key:    8        Vaule:    eight
  41. Key:    9        Vaule:    nine
  43. ************************************************************
  44. DONE
  45. linux@ubuntu:~/16021/glibDemo$

好了，对于功能函数就没有什么多说的了，但是有些同学会想知道存进去的数据在树里面是怎么样的一种存储模型。我也是先来简单的说一下，对于树的遍历分为三种，先序遍历、后序遍历、中序遍历。glib文档中没有给出来遍历的方式，我们是先序遍历来说明。用上面代码中的数据来举例，key是从1到10.

如果使用先序遍历存储模型就是下图：

20160517104440992

从上面这个图中也能明白为什么g_tree_height函数返回值为4了。

在glib中还有一种数据结构叫做n叉树 N-ary Trees

这是树的最一般形式，但是应用却是最少的，现实生活中的N叉树是最多的，但是对于它的操作、算法却是非常的麻烦，在实际使用时往往通过人为方法将n叉树转换为二叉树去进行处理，所以对于n叉树的数据结构就不去了解了。

发表评论

表情：
评论列表 （有 0 条评论，217人围观）

还没有评论，来说两句吧...

相关阅读