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

建立二叉树可以通过递归方式来实现。首先定义一个二叉树节点的结构体，包含数据、左节点和右节点的指针。然后通过递归方式不断地插入节点，直到达到某个条件停止。

递归遍历可以实现前序遍历、中序遍历和后序遍历三种方式。其中前序遍历是先遍历节点本身，然后遍历左子树和右子树；中序遍历是先遍历左子树，然后遍历节点本身，最后遍历右子树；后序遍历是先遍历左子树，然后遍历右子树，最后遍历节点本身。

非递归遍历可以通过栈来实现。对于每个节点，都将其左孩子和右孩子依次入栈，然后弹出栈顶元素进行遍历。这样可以在不使用递归的情况下完成遍历操作。

二叉树的高度可以通过递归方式来实现。对于每个节点，其高度为左右子树高度的较大值加一。通过递归方式遍历二叉树，不断更新高度值，最终得到整个树的高度。

节点查找可以通过递归方式来实现。对于每个节点，如果节点值等于查找值，则返回该节点；否则在左右子树中继续查找，直到遍历完整个树或者找到目标节点。

相关问题

用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);
}

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

二叉树运算和非递归遍历

二叉树是一种重要的数据结构，它的遍历方式有递归和非递归两种。下面将分别介绍二叉树的基本运算和非递归遍历算法。

1. 二叉树的基本运算
建立二叉树的三叉链式存储结构，可以通过以下步骤完成二叉树的基本运算：
- 从键盘上输入二叉树的各个结点，建立三叉链表
- 输出该二叉树
- 递归的先序遍历、中序遍历、后序遍历算法
- 非递归的先序遍历、中序遍历、后序遍历算法
- 非递归的层次遍历算法

2. 非递归遍历算法
非递归遍历算法主要引入了堆栈和队列的思想，下面分别介绍非递归的先序遍历、中序遍历、后序遍历和层次遍历算法。
- 非递归的先序遍历算法：

  def preorderTraversal(root):
      if not root:
          return []
      stack, res = [root], []
      while stack:
          node = stack.pop()
          res.append(node.val)
          if node.right:
              stack.append(node.right)
          if node.left:
              stack.append(node.left)
      return res

- 非递归的中序遍历算法：

  def inorderTraversal(root):
      if not root:
          return []
      stack, res = [], []
      while stack or root:
          if root:
              stack.append(root)
              root = root.left
          else:
              node = stack.pop()
              res.append(node.val)
              root = node.right
      return res

- 非递归的后序遍历算法：

  def postorderTraversal(root):
      if not root:
          return []
      stack, res = [root], []
      while stack:
          node = stack.pop()
          res.append(node.val)
          if node.left:
              stack.append(node.left)
          if node.right:
              stack.append(node.right)
      return res[::-1]

- 非递归的层次遍历算法：

  def levelOrder(root):
      if not root:
          return []
      queue, res = [root], []
      while queue:
          level = []
          for i in range(len(queue)):
              node = queue.pop(0)
              level.append(node.val)
              if node.left:
                  queue.append(node.left)
              if node.right:
                  queue.append(node.right)
          res.append(level)
      return res