blocks|key|2501211|text|只需使用return，除非您真的认为双指针更清晰。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2501212|由于你没有明确说明你的目标，很难给你一个很好的例子：|2501213|2501214|如果多个节点可以匹配v，您的代码将选择最正确的一个，但是|unordered-list-item|2501215|。|2501216|2501217|如果我们可以假设只有一个节点可以匹配v，或者任何匹配的节点都是一个很好的结果，那么您可以优化一些不必要的递归(当然，除非您知道您有理由保护它不受f.e的影响。一种定时侧通道攻击，在所有情况下都在整个树上递归)。|2501218|2501219|因此，下面是一个简单的示例，假设找到的第一次匹配是好的：|2501220|struct+tree+{
+++char+info;
+++struct+tree+*+left;
+++struct+tree+*+right;
};

struct+tree+*+find_matching_node(struct+tree+*+a,+char+v)
{
+++struct+tree+*+found+=+NULL;
+++if+(a+!=+NULL)
+++{
+++++++if+(a->info+==+v)
+++++++{
+++++++++++found+=+a;
+++++++}
+++++++if(found+==+NULL)
+++++++{
+++++++++++found+=+find_matching_node(a->left,+v);
+++++++}
+++++++if(found+==+NULL)
+++++++{
+++++++++++found+=+find_matching_node(a->right,+v);
+++++++}
+++}
+++return+found;
}|code-block|syntax|javascript|2501221|但这里有一个与你的例子完全等价的例子：|2501222|struct+tree+*+find_matching_node(struct+tree+*+a,+char+v)
{
+++struct+tree+*+found+=+NULL;
+++struct+tree+*+found_rightmost;
+++if+(a+!=+NULL)
+++{
+++++++if+(a->info+==+v)
+++++++{
+++++++++++found+=+a;
+++++++}
+++++++if(found+==+NULL)
+++++++{
+++++++++++found+=+find_matching_node(a->left,+v);
+++++++}
+++++++found_rightmost+=+find_matching_node(a->right,+v);
+++++++if(found_rightmost+!=+NULL)
+++++++{
+++++++++++return+found_rightmost;
+++++++}
+++}
+++return+found;
}|2501223|当然，您可以执行双指针，这是一个较小的代码更改：|2501224|void+find_matching_node(struct+tree+*+a,+char+v,+struct+tree+*+*+found)
{
+++if+(a+!=+NULL)+{
++++++find_matching_node(a->left,+v,+found);
++++++if+(a->info+==+v)+*found+=+a;
++++++find_matching_node(a->right,+v,+found);+++
+++}
}|2501225|但是请注意，最后一个版本既保留了递归到整个树的效率低下，又保留了如果存在多个匹配时打算采取哪种行为的模糊性。效率低下的问题可以通过强大的、足够优化的编译器来解决，但是歧义会将代码锁定为始终递归到右半部分，以防在多个匹配的情况下得到最合适的匹配。|2501226|entityMap^0|4|6|0|0|0|A|1|0|0|0|I|1|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1D|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|I|3|J|5|K|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|L|3|M|5|6|7|1I|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]|$1|O|3|P|5|K|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]|$1|R|3|S|5|6|7|1O|8|@]|D|@]|E|$]]|$1|T|3|U|5|V|7|1P|8|@]|D|@]|E|$W|X]]|$1|Y|3|Z|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|10|3|11|5|V|7|1R|8|@]|D|@]|E|$W|X]]|$1|12|3|13|5|6|7|1S|8|@]|D|@]|E|$]]|$1|14|3|15|5|V|7|1T|8|@]|D|@]|E|$W|X]]|$1|16|3|17|5|6|7|1U|8|@]|D|@]|E|$]]|$1|18|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|19|$]]

Just use <code>return</code>, unless you really think the double-pointer is clearer.
Since you've underspecified your goal, it is hard to give you a good example:
<ul>
<li>if more than one node can match <code>v</code>, your code is will pick the right-most one, but
</li>
<li>if we can assume only one node can match <code>v</code>, or any matching node is a good result, then you can optimize out some needless recursion (unless of course you know you're justifiably protecting against f.e. a timing side-channel attack by recursing over the whole tree in all cases).
</li>
</ul>
So, here's the simpler example assuming the first match found is good:
<pre class="lang-c prettyprint-override"><code>struct tree {
 char info;
 struct tree * left;
 struct tree * right;
};

struct tree * find_matching_node(struct tree * a, char v)
{
 struct tree * found = NULL;
 if (a != NULL)
 {
 if (a-&gt;info == v)
 {
 found = a;
 }
 if(found == NULL)
 {
 found = find_matching_node(a-&gt;left, v);
 }
 if(found == NULL)
 {
 found = find_matching_node(a-&gt;right, v);
 }
 }
 return found;
}
</code></pre>
But here's one that's exactly equivalent to your example:
<pre class="lang-c prettyprint-override"><code>struct tree * find_matching_node(struct tree * a, char v)
{
 struct tree * found = NULL;
 struct tree * found_rightmost;
 if (a != NULL)
 {
 if (a-&gt;info == v)
 {
 found = a;
 }
 if(found == NULL)
 {
 found = find_matching_node(a-&gt;left, v);
 }
 found_rightmost = find_matching_node(a-&gt;right, v);
 if(found_rightmost != NULL)
 {
 return found_rightmost;
 }
 }
 return found;
}
</code></pre>
You can of course do the double pointer, which is a smaller code change:
<pre class="lang-c prettyprint-override"><code>void find_matching_node(struct tree * a, char v, struct tree * * found)
{
 if (a != NULL) {
 find_matching_node(a-&gt;left, v, found);
 if (a-&gt;info == v) *found = a;
 find_matching_node(a-&gt;right, v, found); 
 }
}
</code></pre>
But notice that this last version retains both the inefficiency of recursing into the whole tree and the ambiguity about which behavior is intended if there are multiple matches. The inefficiency can be solved by a strong-enough optimizing compiler, but the ambiguity locks the code into always recursing into the right half just in case you intended to get the right-most match in the event of multiple matches.

blocks|key|2404429|text|我同意上面的说法，你应该简单地使用return。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2404430|还可以考虑对指针使用另一层抽象，这完全是个人选择的问题。我个人认为这种类型的指针类型定义使代码更加清晰：|2404431|struct+tree;
typedef+struct+tree+*Position;
typedef+struct+tree
{
+++char+info;
+++Position+left;
+++Position+right;
}+Tree;+|code-block|syntax|javascript|2404432|entityMap^0|H|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

I agree with the above, you should just simply use <code>return</code>.
Consider also the use of another layer of abstraction for pointers, which is completely a matter of personal choice. I personally find this type of pointer type definition makes the code a lot cleaner:
<pre><code>struct tree;
typedef struct tree *Position;
typedef struct tree
{
 char info;
 Position left;
 Position right;
} Tree; 
</code></pre>

blocks|key|2404493|text|按照你的建议，我找到了解决办法。谢谢!下面是代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2404494|find_matching_node(Tree*+a，char+v，Tree**查找){|2404495|如果(a+!=+NULL)+{|2404496|++find_matching_node(a->left,+v,+found);

++if+(a->info+==+v)+*found+=+a;

++find_matching_node(a->right,+v,+found);|code-block|syntax|javascript|2404497|}|2404498|2404499|树*查找(+Tree*+a，char+v)+{|2404500|树*+found+=+NULL；|2404501|如果(a+!=+NULL)+{|2404502|++if+(a->info+==+v)+{

+++++found+=+a;

+++++return+found;

++}

++if(found+==+NULL)+find_matching_node(a->left,+v,+&found);

++if(found+==+NULL)+find_matching_node(a->right,+v,+&found);|2404503|2404504|发现返回；|2404505|2404506|(){|2404507|树*x=查找(根，'a')；|2404508|2404509|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|18|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|9|@]|A|$]]|$1|M|3|L|5|6|7|1B|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1C|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1D|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1E|8|@]|9|@]|A|$]]|$1|T|3|U|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|V|3|L|5|6|7|1G|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1H|8|@]|9|@]|A|$]]|$1|Y|3|L|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1J|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|1K|8|@]|9|@]|A|$]]|$1|13|3|L|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|1M|8|@]|9|@]|A|$]]]|15|$]]

Following your tips, I found the solution. Thanks! Here's the code:
find_matching_node(Tree* a, char v, Tree** found) {
if (a != NULL) {
<pre><code> find_matching_node(a-&gt;left, v, found);

 if (a-&gt;info == v) *found = a;

 find_matching_node(a-&gt;right, v, found);
</code></pre>
}
}
Tree* find(Tree* a, char v) {
Tree* found = NULL;
if (a != NULL) {
<pre><code> if (a-&gt;info == v) {

 found = a;

 return found;

 }

 if(found == NULL) find_matching_node(a-&gt;left, v, &amp;found);

 if(found == NULL) find_matching_node(a-&gt;right, v, &amp;found);
</code></pre>
}
return found;
}
void main() {
Tree* x = find(root, 'a');
}

<pre><code>struct tree {
 char info;
 struct tree* left;
 struct tree* right;
};

typedef struct tree Tree;

Tree* address = NULL; // How to remove this global variable?

void nodeAddress (Tree* a, char v) {
 if (a != NULL) {
 nodeAddress(a-&gt;left, v);
 if (a-&gt;info == v) address = a;
 nodeAddress(a-&gt;right, v); 
 }
}
</code></pre>

How to return a pointer recursively without a global variable in C language?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

struct tree {   char info;   struct tree* left;   struct tree* right;};typedef struct tree Tree;Tree* address = NULL; // How to remove this global variable?void...

问如何在C语言中不使用全局变量递归地返回指针？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在C语言中不使用全局变量递归地返回指针？EN