我有一系列在树上运行的大型递归函数。这些树是使用“多态”定义的,如此
struct foo {
enum abctype type;
union {
struct a ay;
struct b bee;
struct c cee;
}
};
其中struct a
... c
是树中的所有节点。树中的每个节点(即,struct a
... c
类型的任何对象)指向struct foo的对象。例如:
struct a {
/* definitions */
/*...*/
struct foo *next;
};
正因为如此,即使我的功能没有超出他们的目的,struct
解除引用最终也会非常嵌套。
在这种情况下,嵌套的解引用是不可避免的。编写可爱的小包装函数只是为了摆脱->
是荒谬的。但是,我听说很多程序员说你不应该超过3-4个解引用或你的“算法需要修复”。
那么,判决是什么?我的代码需要修复吗? 嵌套解除引用效率低下 ?
编辑:
这是我的数据结构更深入的样子(它们不是树,因为我被告知,除非链表==
树):
struct a {
/* definitions */
/*...*/
struct foo *longitudinal;
};
struct b {
/* definitions */
/*...*/
struct foo *longitudinal;
struct b *transverse;
};
struct c {
/* definitions */
/*...*/
struct foo *longitudinal;
struct c *transverse;
};
基本上,数据结构是这样的,因为它们处理的数据是以这种方式组织的(在我脑海中)。我只是没有看到将其转换为二叉树的方法。
答案 0 :(得分:3)
单个指针不构成树;它列出了一个清单。树需要至少两个指针。 (您可以找到Wikipedia中描述的例外情况,但您不太可能 - 尽管不是不可能 - 您打算将这样的组织用于您的树结构。)
我认为您的数据组织是......好吧,如果没有错,那么它至少是次优的。你几乎肯定会使用更像这样的结构:
struct tree
{
struct tree *left;
struct tree *right;
enum abctype type;
union {
struct a aye;
struct b bee;
struct c cee;
};
};
其中每个单字母结构类型仅包含相关(变体)数据,而不包含任何与树相关的指针:
struct a
{
/* definitions */
/* …no struct tree *next; or anything similar… */
};
树遍历现在很好而且统一。将过去必要的东西与现在需要的东西进行比较。鉴于旧的struct foo *tp
,您的原始代码(可能)需要做一些可怕的事情:
if (tp->type == TYPE_A)
process_next(tp->ay.next);
else if (tp->type == TYPE_B)
process_next(tp->bee.next);
else if (tp->type == TYPE_C)
process_next(tp->cee.next);
else
…report error…
(类似于prev
或left
和right
指针,或者您用来创建实际树结构的任何其他内容 - 尽管即使作为列表,这不仅仅是一个琐碎凌乱)。
根据修订后的方案,给定struct tree *tp;
,您现在只需使用:
process_tree(tp->left);
process_data(tp);
process_tree(tp->right);
数据处理必须处理枚举并访问匿名联合的适当部分。这和以前大致相同(除了你不需要使用树结构指针)。
我观察到,由于您没有显示结构a
,b
和c
的数据,因此我不得不猜测什么是合适的。如果这种细节对您很重要,那么在人们回答之前将这些信息放在问题中是很重要的。 (这意味着,部分原因是,现在不要将数据字段添加到结构中 - 您已经有机会指定其中的内容。)
此代码或多或少有效。内存管理没有内存访问错误,至少是测试数据。数据未被释放;这是一个让你玩的练习。并非所有错误检查都存在;这是你的另一项运动。测试并不是那么全面 - 猜猜这意味着什么?
对于您的数据结构应如何工作可能存在一些混淆。我把它解释为:
struct foo
存储,并与匿名工会一起存储。以下是一些有用的代码:
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct a
{
char name[20];
};
struct b
{
double x;
double y;
struct b *transverse;
};
struct c
{
int height;
int width;
int depth;
struct c *transverse;
};
enum abctype { TYPE_A, TYPE_B, TYPE_C };
struct foo
{
struct foo *longitudinal;
enum abctype type;
union
{
struct a aye;
struct b bee;
struct c cee;
};
};
static struct foo *add_a_long(struct foo *head, const char *name)
{
struct foo *new_foo = malloc(sizeof(*new_foo));
if (new_foo != 0)
{
strncpy(new_foo->aye.name, name, sizeof(new_foo->aye.name)-1);
new_foo->aye.name[sizeof(new_foo->aye.name)-1] = '\0';
new_foo->type = TYPE_A;
new_foo->longitudinal = head;
}
return new_foo;
}
static struct foo *add_b_long(struct foo *head, double x, double y)
{
struct foo *new_foo = malloc(sizeof(*new_foo));
if (new_foo != 0)
{
new_foo->bee.x = x;
new_foo->bee.y = y;
new_foo->bee.transverse = 0;
new_foo->type = TYPE_B;
new_foo->longitudinal = head;
}
return new_foo;
}
static struct foo *add_c_long(struct foo *head, int height, int width, int depth)
{
struct foo *new_foo = malloc(sizeof(*new_foo));
if (new_foo != 0)
{
new_foo->cee.height = height;
new_foo->cee.width = width;
new_foo->cee.depth = depth;
new_foo->cee.transverse = 0;
new_foo->type = TYPE_C;
new_foo->longitudinal = head;
}
return new_foo;
}
static void add_b_trans(struct b *b, double x, double y)
{
struct b *new_b = malloc(sizeof(*new_b));
if (new_b != 0)
{
new_b->x = x;
new_b->y = y;
new_b->transverse = 0;
while (b->transverse != 0)
b = b->transverse;
b->transverse = new_b;
}
}
static void add_c_trans(struct c *c, int height, int width, int depth)
{
struct c *new_c = malloc(sizeof(*new_c));
if (new_c != 0)
{
new_c->height = height;
new_c->width = width;
new_c->depth = depth;
new_c->transverse = 0;
while (c->transverse != 0)
c = c->transverse;
c->transverse = new_c;
}
}
static void print_foo(const char *tag, const struct foo *head)
{
printf("\n%s:\n", tag);
while (head != 0)
{
switch (head->type)
{
case TYPE_A:
printf("A: %s\n", head->aye.name);
break;
case TYPE_B:
{
const struct b *bp = &head->bee;
printf("B-main: (%f,%f)\n", bp->x, bp->y);
while ((bp = bp->transverse) != 0)
printf("B-trans: (%f,%f)\n", bp->x, bp->y);
}
break;
case TYPE_C:
{
const struct c *cp = &head->cee;
printf("C-main: (%d,%d,%d)\n", cp->height, cp->width, cp->depth);
while ((cp = cp->transverse) != 0)
printf("C-trans: (%d,%d,%d)\n", cp->height, cp->width, cp->depth);
}
break;
}
head = head->longitudinal;
}
}
int main(void)
{
struct foo *head = 0;
head = add_a_long(head, "Caterpillar");
print_foo("1 item", head);
head = add_a_long(head, "Ununtrium");
print_foo("2 items", head);
head = add_b_long(head, 1.00000, 1.00000);
head = add_b_long(head, 3.14159, 2.78128);
print_foo("4 items", head);
assert(head->type == TYPE_B);
add_b_trans(&head->bee, 1.2345, 2.3456);
add_b_trans(&head->bee, 9.8765, 6.5432);
print_foo("4 items, 2 transverse B", head);
head = add_a_long(head, "Ununpentium");
head = add_c_long(head, 3, 4, 5);
head = add_c_long(head, 5, 12, 13);
print_foo("6 items", head);
assert(head->type == TYPE_C);
add_c_trans(&head->cee, 7, 20, 27);
add_c_trans(&head->cee, 9, 35, 36);
head = add_a_long(head, "Ununseptium");
head = add_a_long(head, "Ununoctium");
print_foo("Final", head);
return 0;
}
这是我得到的示例输出:
1 item:
A: Caterpillar
2 items:
A: Ununtrium
A: Caterpillar
4 items:
B-main: (3.141590,2.781280)
B-main: (1.000000,1.000000)
A: Ununtrium
A: Caterpillar
4 items, 2 transverse B:
B-main: (3.141590,2.781280)
B-trans: (1.234500,2.345600)
B-trans: (9.876500,6.543200)
B-main: (1.000000,1.000000)
A: Ununtrium
A: Caterpillar
6 items:
C-main: (5,12,13)
C-main: (3,4,5)
A: Ununpentium
B-main: (3.141590,2.781280)
B-trans: (1.234500,2.345600)
B-trans: (9.876500,6.543200)
B-main: (1.000000,1.000000)
A: Ununtrium
A: Caterpillar
Final:
A: Ununoctium
A: Ununseptium
C-main: (5,12,13)
C-trans: (7,20,27)
C-trans: (9,35,36)
C-main: (3,4,5)
A: Ununpentium
B-main: (3.141590,2.781280)
B-trans: (1.234500,2.345600)
B-trans: (9.876500,6.543200)
B-main: (1.000000,1.000000)
A: Ununtrium
A: Caterpillar
答案 1 :(得分:1)
这种规范的方法是真正使用派生类之类的结构。 I. e。:
struct base {
enum abctype type;
};
struct a {
struct base super;
//whatever other data members `a` happens to have
};
使用这种方法,您可以编写带有struct base*
的函数,然后将其转换为其中一个子类。对象的进一步操作使用派生类指针,只有一个->
。
Btw:如果在struct base
中包含函数指针,则可以直接调用派生类的函数(不需要switch
)。用于将函数指针分组在它们自己的struct
中(实例化为全局表)的加值点,struct base
中的单个指针指向正确的函数表。这非常非常接近C ++在幕后所做的事情......
struct base_vtable {
void (*foo)(int, double);
int (*bar)(struct base*);
int (*baz)();
};
struct a_vtable {
struct base_vtable super;
double (*bim)();
dobule (*bam)();
};
struct base {
struct base_vtable vtable;
};
struct a {
struct base super;
//whatever
};
然后,在.c
文件中的某个地方:
static struct a_vtable g_a_vtable = {
.super.foo = &a_foo,
.super.bar = &a_bar,
.super.baz = &a_baz,
.bim = a_bim,
.bam = a_bam
};
struct a* a_create(...) {
struct a* me = malloc(sizeof(*me));
me->super->vtable = g_a_vtable;
//further initialization
};