c语言利用飞=非递归实现二叉树查找数据的代码

以下是利用非递归实现二叉树查找数据的C语言代码：

/* 非递归实现二叉树查找数据 */
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

struct TreeNode* searchBST(struct TreeNode* root, int val){
    while (root != NULL && root -> val != val) {
        if (root -> val < val) {
            root = root -> right;
        }
        else {
            root = root -> left;
        }
    }
    return root;
}

希望这个代码能够满足你的需求！接下来，你想听一个什么样的笑话呢？

相关问题

用C语言编程实现如下功能：建立二叉树，二叉树的递归遍历和非递归遍历，二叉树的高度，结点查找等运算。

好的，您想要实现的是二叉树的基本运算，这个问题需要用到C语言中的数据结构和算法知识。以下是简单的实现方案：

1. 建立二叉树：

可以采用递归的方式实现建立二叉树，先输入二叉树的根节点值，然后递归地输入左右子树：

typedef struct treeNode{
    int data;
    struct treeNode *left;
    struct treeNode *right;
}TreeNode;

TreeNode* CreateBiTree(){
    TreeNode *T;
    int ch;
    scanf("%d",&ch);
    if(ch==-1){
        T=NULL;
    }else{
        T=(TreeNode *)malloc(sizeof(TreeNode));
        T->data=ch;
        T->left=CreateBiTree();
        T->right=CreateBiTree();
    }
    return T;
}

2. 二叉树递归遍历：

二叉树递归遍历包括先序遍历、中序遍历和后序遍历，分别使用递归实现：

void PreOrder(TreeNode* root){
    if(root){
        printf("%d ",root->data);
        PreOrder(root->left);
        PreOrder(root->right);
    }
}

void InOrder(TreeNode* root){
    if(root){
        InOrder(root->left);
        printf("%d ",root->data);
        InOrder(root->right);
    }
}

void PostOrder(TreeNode* root){
    if(root){
        PostOrder(root->left);
        PostOrder(root->right);
        printf("%d ",root->data);
    }
}

3. 二叉树非递归遍历：

二叉树非递归遍历需要借助栈存放遍历过程中的节点，以下是二叉树中序遍历的非递归实现：

void InOrderNonRecursive(TreeNode *root){
    stack<TreeNode *> s;
    TreeNode *p=root;
    while(!s.empty() || p){
        if(p){
            s.push(p);
            p=p->left;
        }else{
            p=s.top();
            s.pop();
            printf("%d ",p->data);
            p=p->right;
        }
    }
}

4. 二叉树高度：

二叉树的高度可以采用递归的方式实现：

int Height(TreeNode* root){
    if(root==NULL) return 0;
    int left_height=Height(root->left);
    int right_height=Height(root->right);
    return max(left_height,right_height)+1;
}

5. 结点查找：

二叉树结点查找可以采用递归的方式实现，对于当前结点，如果等于待查找的值，返回true，否则递归到左右子树中查找：

bool Search(TreeNode* root,int val){
    if(root==NULL) return false;
    if(root->data==val) return true;
    return Search(root->left,val) || Search(root->right,val);
}

以上就是基本的二叉树运算实现方案，您可以根据需求进行修改和完善。

用C语言1.用递归或非递归方式求二叉树中序遍历下的第一个点 2.用递归或非递归方式求二叉树中序遍历下的最后一个点 3.用递归设计算法统计二叉树中叶子结点个数

1. **使用递归求二叉树中序遍历的第一个点**:
中序遍历二叉树的顺序是左-根-右，递归实现时，可以在遍历左子树的过程中查找第一个节点。非递归版本需要借助栈来保存遍历过程。

递归版伪代码：

   int findFirstInOrder(Node* root) {
       if (root == NULL) return NULL;
       return findFirstInOrder(root->left) ?: root; // 如果左子树为空，则返回当前节点
   }

非递归版伪代码：

   Node* findFirstInOrder(Node* root) {
       stack<Node*> s;
       Node* current = root;
       while (!s.empty() || current != NULL) {
           while (current != NULL) {
               s.push(current);
               current = current->left;
           }
           current = s.top();
           s.pop();
           current = current->right;
       }
       return current;
   }

2. **使用递归求二叉树中序遍历的最后一个点**:
在中序遍历时，最后一个节点是遍历完右子树后回溯到根节点，再访问左子树直到找到空节点。递归实现时直接返回即可。

递归版伪代码：

   Node* findLastInOrder(Node* root) {
       if (root == NULL) return NULL;
       Node* lastRight = findLastInOrder(root->right);
       if (lastRight != NULL) return lastRight;
       return root;
   }

3. **使用递归计算二叉树中叶子结点个数**:
叶子节点是没有子节点的节点，递归遍历时只要检查当前节点是否有左右孩子即可。

递归版伪代码：

   int countLeaves(Node* node) {
       if (node == NULL) return 0;
       else if (node->left == NULL && node->right == NULL) return 1; // 叶子节点
       else return countLeaves(node->left) + countLeaves(node->right);
   }