4_15_GLib库入门与实践_N叉树

于 2022-03-13 00:16:19 发布
阅读量420 收藏 1
点赞数
分类专栏： GLib库入门与实践 文章标签： 数据结构 N叉树 GLib c语言 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/field1003/article/details/123436033
版权

简介

平衡二叉树是一种特殊的树，前面已经介绍过。本章介绍的是N叉树。
（本节以下内容翻译自官方文档）
GNode 结构及其相关函数提供了一个 N 叉树数据结构，其中树中的节点可以包含任意数据。
要创建一棵新树，请使用 g_node_new()。
要将节点插入树中，请使用 g_node_insert()、g_node_insert_before()、g_node_append() 和 g_node_prepend()。
要创建一个新节点并将其插入树中，请使用 g_node_insert_data()、g_node_insert_data_after()、g_node_insert_data_before()、g_node_append_data() 和 g_node_prepend_data()。
要反转节点的子节点，请使用 g_node_reverse_children()。
要查找节点，请使用 g_node_get_root()、g_node_find()、g_node_find_child()、g_node_child_index()、g_node_child_position()、g_node_first_child()、g_node_last_child()、g_node_nth_child()、g_node_first_sibling()、g_node_prev_sibling()、g_node_next_sibling() 或 g_node_last_sibling()。
要获取有关节点或树的信息，请使用 G_NODE_IS_LEAF()、G_NODE_IS_ROOT()、g_node_depth()、g_node_n_nodes()、g_node_n_children()、g_node_is_ancestor() 或 g_node_max_height()。
要遍历树，为遍历中访问的每个节点调用一个函数，使用 g_node_traverse() 或 g_node_children_foreach()。
要从树中删除节点或子树，请使用 g_node_unlink() 或 g_node_destroy()。

数据结构

树上的一个节点，各成员变量含义如下。

struct GNode {
  gpointer data; // 指向用户数据的指针
  GNode   *next; // 下一个节点
  GNode   *prev;  // 上一个节点
  GNode   *parent;  // 父节点
  GNode   *children;  // 子节点
};

函数列表

GNode * 	g_node_new ()
GNode * 	g_node_copy ()
gpointer 	(*GCopyFunc) ()
GNode * 	g_node_copy_deep ()
GNode * 	g_node_insert ()
GNode * 	g_node_insert_before ()
GNode * 	g_node_insert_after ()
#define 	g_node_append()
GNode * 	g_node_prepend ()
#define 	g_node_insert_data()
#define 	g_node_insert_data_after()
#define 	g_node_insert_data_before()
#define 	g_node_append_data()
#define 	g_node_prepend_data()
void 	g_node_reverse_children ()
void 	g_node_traverse ()
gboolean 	(*GNodeTraverseFunc) ()
void 	g_node_children_foreach ()
void 	(*GNodeForeachFunc) ()
GNode * 	g_node_get_root ()
GNode * 	g_node_find ()
GNode * 	g_node_find_child ()
gint 	g_node_child_index ()
gint 	g_node_child_position ()
#define 	g_node_first_child()
GNode * 	g_node_last_child ()
GNode * 	g_node_nth_child ()
GNode * 	g_node_first_sibling ()
#define 	g_node_next_sibling()
#define 	g_node_prev_sibling()
GNode * 	g_node_last_sibling ()
#define 	G_NODE_IS_LEAF()
#define 	G_NODE_IS_ROOT()
guint 	g_node_depth ()
guint 	g_node_n_nodes ()
guint 	g_node_n_children ()
gboolean 	g_node_is_ancestor ()
guint 	g_node_max_height ()
void 	g_node_unlink ()
void 	g_node_destroy ()

函数功能分类

创建

GNode * g_node_new ()

复制

GNode * g_node_copy ()
GNode * g_node_copy_deep ()

插入

GNode * g_node_insert ()
GNode * g_node_insert_before ()
GNode * g_node_insert_after ()
#define g_node_append()
GNode * g_node_prepend ()
#define g_node_insert_data()
#define g_node_insert_data_after()
#define g_node_insert_data_before()
#define g_node_append_data()
#define g_node_prepend_data()

子节点反转

void g_node_reverse_children ()

遍历及子节点遍历

void g_node_traverse ()
void g_node_children_foreach ()

查找

GNode * g_node_get_root ()
GNode * g_node_find ()
GNode * g_node_find_child ()

定位

gint g_node_child_index ()
gint g_node_child_position ()
#define g_node_first_child()
GNode * g_node_last_child ()
GNode * g_node_nth_child ()
GNode * g_node_first_sibling ()
#define g_node_next_sibling()
#define g_node_prev_sibling()
GNode * g_node_last_sibling ()

判断

// 是否为叶子节点
#define G_NODE_IS_LEAF()
// 是否为树的根节点
#define G_NODE_IS_ROOT()

是否为节点的祖先

gboolean g_node_is_ancestor ()

节点深度

guint g_node_depth ()

节点编号

guint g_node_n_nodes ()

节点的子节点

guint g_node_n_children ()

树的最大高度

guint g_node_max_height ()

删除

void g_node_unlink ()

释放

void g_node_destroy ()

函数功能说明及综合演示

N叉树的综合演示

下面示例程序来自官方测试代码，演示了N叉树的创建、插入、查找、遍历、销毁等操作。
源码见glib_examples\glib_node\glib_node_basic

#include <glib.h>

#define	C2P(c)		((gpointer) ((long) (c)))
#define	P2C(p)		((gchar) ((gintptr) (p)))

static gboolean node_build_string (GNode *node, gpointer data)
{
    gchar **p = data;
    gchar *string;
    gchar c[2] = "_";

    c[0] = ((gchar) ((gintptr) (node->data)));

    string = g_strconcat (*p ? *p : "", c, NULL);
    g_free (*p);
    *p = string;

    return FALSE;
}

static void glib_node_basic_test (void)
{
    GNode *root;
    GNode *node;
    GNode *node_B;
    GNode *node_F;
    GNode *node_G;
    GNode *node_J;
    guint i;
    gchar *tstring, *cstring;

    root = g_node_new (C2P ('A'));
    g_assert (g_node_depth (root) == 1 && g_node_max_height (root) == 1);

    node_B = g_node_new (C2P ('B'));
    g_node_append (root, node_B);
    g_assert (root->children == node_B);

    g_node_append_data (node_B, C2P ('E'));
    g_node_prepend_data (node_B, C2P ('C'));
    g_node_insert (node_B, 1, g_node_new (C2P ('D')));

    node_F = g_node_new (C2P ('F'));
    g_node_append (root, node_F);
    g_assert (root->children->next == node_F);

    node_G = g_node_new (C2P ('G'));
    g_node_append (node_F, node_G);
    node_J = g_node_new (C2P ('J'));
    g_node_prepend (node_G, node_J);
    g_node_insert (node_G, 42, g_node_new (C2P ('K')));
    g_node_insert_data (node_G, 0, C2P ('H'));
    g_node_insert (node_G, 1, g_node_new (C2P ('I')));

    g_assert (g_node_depth (root) == 1);
    g_assert (g_node_max_height (root) == 4);
    g_assert (g_node_depth (node_G->children->next) == 4);
    g_assert (g_node_n_nodes (root, G_TRAVERSE_LEAFS) == 7);
    g_assert (g_node_n_nodes (root, G_TRAVERSE_NON_LEAFS) == 4);
    g_assert (g_node_n_nodes (root, G_TRAVERSE_ALL) == 11);
    g_assert (g_node_max_height (node_F) == 3);
    g_assert (g_node_n_children (node_G) == 4);
    g_assert (g_node_find_child (root, G_TRAVERSE_ALL, C2P ('F')) == node_F);
    g_assert (g_node_find (root, G_LEVEL_ORDER, G_TRAVERSE_NON_LEAFS, C2P ('I')) == NULL);
    g_assert (g_node_find (root, G_IN_ORDER, G_TRAVERSE_LEAFS, C2P ('J')) == node_J);

    for (i = 0; i < g_node_n_children (node_B); i++)
    {
    node = g_node_nth_child (node_B, i);
    g_assert (P2C (node->data) == ('C' + i));
    }

    for (i = 0; i < g_node_n_children (node_G); i++)
    g_assert (g_node_child_position (node_G, g_node_nth_child (node_G, i)) == i);

    /* we have built:                    A
    *                                 /   \
    *                               B       F
    *                             / | \       \
    *                           C   D   E       G
    *                                         / /\ \
    *                                       H  I  J  K
    *
    * for in-order traversal, 'G' is considered to be the "left"
    * child of 'F', which will cause 'F' to be the last node visited.
    */

    tstring = NULL;
    g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
    g_assert_cmpstr (tstring, ==, "ABCDEFGHIJK");
    g_free (tstring); tstring = NULL;
    g_node_traverse (root, G_POST_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
    g_assert_cmpstr (tstring, ==, "CDEBHIJKGFA");
    g_free (tstring); tstring = NULL;
    g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
    g_assert_cmpstr (tstring, ==, "CBDEAHGIJKF");
    g_free (tstring); tstring = NULL;
    g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
    g_assert_cmpstr (tstring, ==, "ABFCDEGHIJK");
    g_free (tstring); tstring = NULL;

    g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_LEAFS, -1, node_build_string, &tstring);
    g_assert_cmpstr (tstring, ==, "CDEHIJK");
    g_free (tstring); tstring = NULL;
    g_node_traverse (root, G_PRE_ORDER, G_TRAVERSE_NON_LEAFS, -1, node_build_string, &tstring);
    g_assert_cmpstr (tstring, ==, "ABFG");
    g_free (tstring); tstring = NULL;

    g_node_reverse_children (node_B);
    g_node_reverse_children (node_G);

    g_node_traverse (root, G_LEVEL_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
    g_assert_cmpstr (tstring, ==, "ABFEDCGKJIH");
    g_free (tstring); tstring = NULL;

    cstring = NULL;
    node = g_node_copy (root);
    g_assert (g_node_n_nodes (root, G_TRAVERSE_ALL) == g_node_n_nodes (node, G_TRAVERSE_ALL));
    g_assert (g_node_max_height (root) == g_node_max_height (node));
    g_node_traverse (root, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &tstring);
    g_node_traverse (node, G_IN_ORDER, G_TRAVERSE_ALL, -1, node_build_string, &cstring);
    g_assert_cmpstr (tstring, ==, cstring);
    g_free (tstring); tstring = NULL;
    g_free (cstring); cstring = NULL;
    g_node_destroy (node);

    g_node_destroy (root);

    /* allocation tests */

    root = g_node_new (NULL);
    node = root;

    for (i = 0; i < 2048; i++)
    {
        g_node_append (node, g_node_new (NULL));
        if ((i%5) == 4) {
            node = node->children->next;
        }
    }
    g_assert (g_node_max_height (root) > 100);
    g_assert (g_node_n_nodes (root, G_TRAVERSE_ALL) == 1 + 2048);

    g_node_destroy (root);

}

gint main(gint argc, gchar **argv)
{
    glib_node_basic_test();

    return 0;
}
field1003
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Glib库简介.pdf
10-26
Glib库简介.pdf Glib库简介.pdfGlib库简介.pdfGlib库简介.pdfGlib库简介.pdf
U8glib_forwardveg_U8glib\utility_u8glib支持oled_u8glib_u8glib库下载_源
10-03
u8glib库支持多种oled显示驱动，功能强大
Glib 使用说明 & 学习笔记
01-07 1400
Glib是一种底层库，创建 GDK 和 GTK应用程序时该库可提供许多有用的定义和函数。它们包括基本类型及限制的定义、标准宏、类型转换、字节序、存储分配、警告和断言、消息记录、计时器、字符串工具 (string utilities)、挂钩 (hook)函数、一个句法扫描器、动态加载模块和自动字符串补全，它也定义了许多数据结构(及其相应的操作)，包括存储块、双向链表、单向链表、哈希表
glib安装详细教程
Answer的博客
11-09 7937
一、安装glib wget http://ftp.acc.umu.se/pub/GNOME/sources/glib/2.45/glib-2.45.2.tar.xz tar-xfglib-2.45.2.tar.xz 1、进入目录文件中 ./configure make make install 如果没什么问题就直接看第四部分。若有问题看参考下面 二、 ./configure时的问题 1、zlib库的问题 如果发现报错，没有zli...
4_04_GLib库入门与实践_指针数组
field1003的博客
03-12 803
简介 GLib提供了三种类型的数组，普通数组，指针数组和字节数组，本节讨论指针数组。 在上一节介绍GArray动态数组时，数组元素可以是int类型，也可以是一个结构体类型，甚至结构体中的成员变量还可以是一个指针，但根据其内存模型一节，每个数组元素的长度都是固定的，如果我们想存长度不固定的字符串怎么办？一种方法是利用带指针的结构体，将字符串存在结构体的指针成员变量中，另一种方法就是指针数组了。 数据结构 普通数组和指针数组的结构体定义如下： 普通数组 struct GArray { gchar *data
3_06_GLib库入门与实践_正则表达式
field1003的博客
03-12 715
简介 GLib正则表达式Regex依赖PCRE库，在编译时，如果configure参数指定的是internal，则使用GLib内部自带的PCRE库，如果没有指定internal参数，则会使用系统的PCRE库。 数据结构 enum GRegexCompileFlags // 编译标识， enum GRegexMatchFlags // 匹配标识 struct GRegex //正则表达式的编译形式，这是一个不透明结构体 struct GMatchInfo //不透明结构体，内含匹配信息 函数列
message_pump_glib.rar_On Message
09-24
A brief refresher on GLib: Source Code for Linux.
WDTandEINT.rar_glib.h 2410
09-14
三星ARM2410的看门狗与中断结合实验
glib-html-2.6.6.tar.gz_glib_glib-2.6.6.tar.b_linux gl
09-22
glid编写实例，glid应用，可供参考。
U8glib-1.19.1.rar_arduino stm32_stm32移植u8glib_u8glib_u8glib stm
09-20
stm32 u8glib arduino
glib使用平衡二叉树实现读配置文件
°Destiny
05-05 321
glib
4_10_GLib库入门与实践_平衡二叉树
field1003的博客
03-13 693
简介 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法）。它具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。平衡二叉树的插入，查找，删除时间复杂度均为O(logN)。 数据结构 平衡二叉树的数据结构GTree是不透明结构体，只能作为整体使用，无法直接引用其内部变量。 typedef struct _GTree GTree; 函数列表 GTree * g_tree_new () GTree * g_tree
Glib学习（18） 基于二叉树的队列 Sequences
andylauren的专栏
04-30 2485
glib源码下载：http://ftp.gnome.org/pub/gnome/sources/glib/ glib帮助文档：https://developer.gnome.org/glib/ 本节主要讲解一下Sequences-序列，这个序列的实现是基于二叉树，所以在查找的效率上是非常高的，而且有非常丰富的基于迭代器的函数。 我把函数使用谷歌翻译了一下，没有仔细校验，因为英语是在太差，而且
GBase 8a报错信息Failed to query in gnode的原因分析和解决
jingjing1068的博客
11-29 5264
当GBase 8a数据库集群将业务SQL下发到计算节点执行时，如果某些节点报错，则会报出Failed to query in gnode的信息。该错误信息是通用报错信息，需要根据DETAIL的具体报错信息进行有针对性的排查。 报错样例 如下是最典型的样例，重点是如下三大部分 错误码 1708 IP信息，表示报错的节点 10.0.2.107 端口5050表示是计算节点gnode DETAIL的报错原因 File ‘/home/gbase/t1.txt’ already exists 报错的SQL，注意是gno
glib简介
evsqiezi
09-09 5467
1 glibc 是gnu发布的libc库，也即c运行库。 2 glib是gtk+的一套函数库,gobject是glib的精粹，glib是用C实现的.glib提供了动态数组、单/双向链表、哈希表、多叉树、平衡二叉树、字符串等常用容器，完全是面向对象设计的，实现得非常精致。不用白不用，别客气了。 3 类型定义： 整数类型：gint8,guint8,gint16,guint16,gint32,gui...
GLib常用函数简介
hehongjihhh的专栏
08-22 6023
如果在程序中要使用到glib库中的函数，则应该包含glib.h头文件（在gtk.h和gnome.h头文件中已经包含了glib.h了） 1 类型定义 1. 整数类型：gint8、guint8、gint16、guint16、gint31、guint32、gint64、guint64。不是所有的平台都提供64位整型  2. 整数类型gshort、glong、gint和short、long、
glib库阅读
evsqiezi
12-30 236
gatomic.h 实现原子操作，Windows下用InterlockedExchangeAdd等实现。 gbitlock.c 对bit进行加锁，直到调用g_bit_unlock。 gbase64.c base64加解密。 gbuffer.c buf的创建，删除。 gcache.h 实现cache。 ghash.h 实现hash。 ghook.c 实现hook类型的双链表GHookList。 ghostutils.c 英特网主机名工具。 giowin32.c 实现对IO的读写，例如g_..
3_01_GLib库入门与实践_测试框架
field1003的博客
03-11 1624
简介 GLib提供了一套测试框架，可以帮助我们实现自动测试，而且还能生成报告，下面简单介绍一下这个框架的基本使用方法。 数据结构 enum GTestFileType enum GTestTrapFlags enum GTestSubprocessFlags typedef GTestCase // 测试例 typedef GTestSuite // 测试套件，一个TestSuite可包含多个TestCase 函数列表 void g_test_minimized_result () voi
g_object_new_with_properties方法在glib的哪里
最新发布
05-25
g_object_new_with_properties方法在GLib的Object类型的源文件"gobject/gobject.c"中实现。该方法是从g_object_newv()方法派生而来的，它允许在创建新对象时设置属性。它接受一个GObjectClass指针和一个NULL结束的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值