精华内容
下载资源
问答
  • 建立位数组,然后以位数组为例进行二叉排序树中序遍历
  • !... 我看书上说“二叉排序树中序遍历结果是递增序列”,然后我随便写了几个数,生成二叉排序树进行中序遍历,结果如上图,它不是递增序列啊???是我知识上有什么漏洞吗?求教啊~~
  • 二叉排序树中序遍历是递增的!!!记住

    二叉排序树的中序遍历是递增的!!!记住

    展开全文
  • 二叉排序树-中序遍历

    2012-06-14 10:32:21
    采用llink-rlink方式存储二叉排序树,编写能够通过键盘输入建立二叉排序树,并在建立完立即在屏幕显示中序遍历结果的程序
  • 二叉搜索中序遍历也可以实现排序 package org.exam.ch8; /** * Created by xin on 15.10.14. */ class Node{ public int iData; public double dData; public Node leftChild; public Node rightChild; ...

    二叉搜索树的中序遍历也可以实现排序

    package org.exam.ch8;
    
    /**
     * Created by xin on 15.10.14.
     */
    class Node{
        public int iData;
        public double dData;
        public Node leftChild;
        public Node rightChild;
        @Override
        public String toString() {
            return "Node{" +
                    "iData=" + iData +
                    ", dData=" + dData +
                    '}';
        }
    }
    class Tree{
        private Node root;
        public Node find(int key){
            Node current=root;
            while (current.iData!=key){
                if (key<current.iData){
                    current=current.leftChild;
                }else{
                    current=current.rightChild;
                }
            }
            if (current==null){
                return null;
            }
            return current;
        }
        public void insert(int iData,double dData){
            Node newNode=new Node();
            newNode.iData=iData;
            newNode.dData=dData;
            if (root==null){
                root=newNode;
            }else{
                Node current=root;
                Node parent=null;
                while (true){
                    parent=current;
                    if (iData<current.iData){
                        current=current.leftChild;
                        if (current==null){
                            parent.leftChild=newNode;
                            return;
                        }
                    }else{
                        current=current.rightChild;
                        if (current==null){
                            parent.rightChild=newNode;
                            return;
                        }
                    }
                }
            }
        }
        public void traverse(int traverseType){
            switch(traverseType){
                case 1: System.out.print("\nPreorder traversal: ");
                    preOrder(root);
                    break;
                case 2: System.out.print("\nInorder traversal:  ");
                    inOrder(root);
                    break;
                case 3: System.out.print("\nPostorder traversal: ");
                    postOrder(root);
                    break;
            }
            System.out.println();
        }
        private void preOrder(Node localRoot){
            if (localRoot!=null){
                System.out.print(localRoot.iData + " ");
                inOrder(localRoot.leftChild);
                inOrder(localRoot.rightChild);
            }
        }
        private void inOrder(Node localRoot){
            if (localRoot!=null){
                inOrder(localRoot.leftChild);
                System.out.print(localRoot.iData+" ");
                inOrder(localRoot.rightChild);
            }
        }
        private void postOrder(Node localRoot){
            if (localRoot!=null){
                inOrder(localRoot.leftChild);
                inOrder(localRoot.rightChild);
                System.out.print(localRoot.iData+" ");
            }
        }
        public Node minimum(){
            Node current=root;
            while (current!=null){
                if (current.leftChild==null){
                    return current;
                }else{
                    current=current.leftChild;
                }
            }
            return current;
        }
        public Node maximum(){
            Node current=root;
            while (current!=null){
                if (current.rightChild==null){
                    return current;
                }else{
                    current=current.rightChild;
                }
            }
            return current;
        }
        public boolean delete(int key){
            Node current=root;
            Node parent=null;
            boolean isLeftChild=false;//找到的节点不是根时(所以初如化时真假亦可),isLeftChild指的是current是不是parent的左子节点.
            while (current.iData!=key){
                parent=current;
                if (key<current.iData){
                    isLeftChild=true;
                    current=current.leftChild;
                }else{
                    isLeftChild=false;
                    current=current.rightChild;
                }
                if (current==null){//没有找到要删除的节点
                    return false;
                }
            }
            //走到这里表明已找到的节点正是current所指向的节点
            if (current.leftChild==null&¤t.rightChild==null){//是叶节点,即没有左右子节点
                if (current==root){//如果找到的是根,设为null即可,
                    root=null;
                }else if (isLeftChild){//如果找到的是一个节点的左子节点,那么将这个节点的左子节点设为null
                    parent.leftChild=null;
                }else {//同理,如果找到的是一个节点的右子节点,那么将这个节点的右子节点设为null即可.
                    parent.rightChild=null;
                }
            }else if (current.rightChild==null){//左子节点不存在,右子节点存在
                if (current==root){
                    root=current.leftChild;
                }else if (isLeftChild){
                    parent.leftChild=current.leftChild;
                }else{
                    parent.rightChild=current.leftChild;
                }
            }else if (current.leftChild==null){//左子节点存在,右子节点不存在
                if (current==root){
                    root=current.rightChild;
                }else if (isLeftChild){
                    parent.leftChild=current.rightChild;
                }else{
                    parent.rightChild=current.rightChild;
                }
            }else{//左右子节点都存在
                Node successor=getSuccessor(current);//找一个比删除节点大得最少的一个节点(当然我认为找一个比删除节点小得最少的一个节点也可以)作为后继节点
                if (current==root){
                    root=successor;
                }else if (isLeftChild){
                    parent.leftChild=successor;
                }else{
                    parent.rightChild=successor;
                }
                successor.leftChild=current.leftChild;//后继节点左子节点连接原删除节点的左子节点;后继节点右子节点连接在getSuccessor已处理(删除后,当然后继节点的右子节点也可能不存在)
            }
            return true;
        }
        private Node getSuccessor(Node delNode) {
            Node successorParent=delNode;
            Node successor=null;
            Node current=delNode.rightChild;//从删除节点的右子节点开始找
            while (current!=null){
                successorParent=successor;//将successor的父节点使用successorParent缓存下来
                successor=current;//先将最后找到的节点缓存下来
                current=current.leftChild;//往左子节点找,直到左子点为null时,停止查找
            }
            //此时的current一定为null,successor就是后继节点.如果后继节点正是删除节点的右子节点,就返回处理即可;否则,先处理好这个断掉的后继节点
            if (successor!=delNode.rightChild){
                successorParent.leftChild=successor.rightChild;
                successor.rightChild=delNode.rightChild;
            }
            return successor;
        }
    }
    public class TreeApp {
        public static void main(String[] args) {
            Tree tree=new Tree();
            tree.insert(50,1.5);
            tree.insert(25,1.7);
            tree.insert(75,1.9);
            tree.insert(15,1.3);
            tree.insert(17,1.1);
            tree.insert(35,2.9);
            tree.insert(54,3.2);
    
            /*
            Node found=tree.find(25);
            if (found != null) {
                System.out.println("Found the node with key 25");
            }else{
                System.out.println("Couldn't find node with key 25");
            }
            System.out.println("maximum = " + tree.maximum());
            System.out.println("minimum = " + tree.minimum());
            */
            tree.traverse(2);
    
        }
    }
    


    展开全文
  • 实现要求: ...该二叉树类提供方法进行节点的追加(追加节点时,构建二叉排序树),并提 供中序遍历二叉树节点的方法。 BinaryTreeNode类 public class BinaryTreeNode { private int data; priv...

    实现要求:

    设计二叉树类(BinaryTree),该类内部使用二叉树结构存放二叉树节点 (BinaryTreeNode),每个节点可存放一个整数值。
     该二叉树类提供方法进行节点的追加(追加节点时,构建二叉排序树),并提 供中序遍历二叉树节点的方法。

    分析:

    随机生成部分整数值{10,3,20,7,5,33,27,100,0}

    以上整数值,生成二叉排序树应如下:

    不同排序方式,排序结果应为:

    先序排列:根--左--右,10,3,0,7,5,20,33,27,100

    中序排列:左--根--右,0,3,5,7,10,20,27,33,100(二叉排序树的中序遍历,为升序排列)

    后序排列:左--右--根,0,5,7,3,27,100,33,20,10

    BinaryTreeNode类(已省略getter和setter方法):

    public class BinaryTreeNode {
    	private int info;
    	private BinaryTreeNode left;
    	private BinaryTreeNode right;
    
    	public BinaryTreeNode() {
    		super();
    	}
    
    	public BinaryTreeNode(int info) {
    		super();
    		this.info = info;
    	}
    
    	public BinaryTreeNode(int info, BinaryTreeNode left, BinaryTreeNode right) {
    		super();
    		this.info = info;
    		this.left = left;
    		this.right = right;
    	}
    }
    

    BinaryTree类:

    /**
     * 设计二叉树类(BinaryTree),该类内部使用二叉树结构存放二叉树节点 (BinaryTreeNode),每个节点可存放一个整数值。
     * 该二叉树类提供方法进行节点的追加(追加节点时,构建二叉排序树),并提 供中序遍历二叉树节点的方法。
     *
     */
    public class BinaryTree {
    	private static BinaryTreeNode root;
    
    	public static void main(String[] args) {
    		BinaryTreeNode node = null;
    		int[] array = {10,3,20,7,5,33,27,100,0};
    		for(int i=0;i<array.length;i++){
    			node = new BinaryTreeNode(array[i]);
    			addTreeNode(node);
    		}
    		inOrderTraversal();//输出结果:0,3,5,7,10,20,27,33,100,
    	}
    
    	/**
    	 * 中序遍历二叉树
    	 */
    	private static void inOrderTraversal() {
    		if (root == null) {
    			return;
    		}
    		middleOrder(root);
    	}
    	
    	private static void middleOrder(BinaryTreeNode current) {
    		if (current.getLeft() != null) {
    			// 遍历左子树
    			middleOrder(current.getLeft());
    		}
    		System.out.print(current.getInfo() + ",");
    		if (current.getRight() != null) {
    			// 遍历右子树
    			middleOrder(current.getRight());
    		}
    	}
    
    	/**
    	 * 追加二叉树节点;追加节点时,构建二叉排序树
    	 * 
    	 * @param node
    	 * @return
    	 */
    	private static boolean addTreeNode(BinaryTreeNode node) {
    		if (root == null) {
    			root = node;
    			return true;
    		}
    		BinaryTreeNode current = root;
    		while (node != null) {
    			if (node.getInfo() < current.getInfo()) {
    				if (current.getLeft() == null) {
    					current.setLeft(node);
    					return true;
    				} else {
    					current = current.getLeft();
    				}
    			} else if (node.getInfo() > current.getInfo()) {
    				if (current.getRight() == null) {
    					current.setRight(node);
    					return true;
    				} else {
    					current = current.getRight();
    				}
    			} else {
    				//二叉排序树中,不能存在数值相等的节点,否则错误
    				System.out.println("repeat");
    				return false;
    			}
    		}
    		return false;
    	}
    }
    

     

    展开全文
  • #include <iostream> #include <cstdio> #include <queue> using namespace std;...struct TreeNode{ ...TreeNode* Insert(TreeNode* root, int x){//二叉排序树建树 if(root == NULL){
    #include <iostream>
    #include <cstdio>
    #include <queue>
    using namespace std;
    struct TreeNode{
        int data;
        TreeNode *leftchild;
        TreeNode *rightchild;
    };
    
    TreeNode* Insert(TreeNode* root, int x){//二叉排序树建树
        if(root == NULL){
            root = new TreeNode();
            root->data = x;
            root->leftchild = NULL;
            root->rightchild = NULL;
        }else if(x < root->data){
            root->leftchild = Insert(root->leftchild,x);
        }else{
            root->rightchild = Insert(root->rightchild,x);
        }
        return root;
    }
    void InOrder(TreeNode* root){//二叉排序树中序输出升序所以叫排序树
        if(root != NULL){
            InOrder(root->leftchild);
            printf("%d\n",root->data);
            InOrder(root->rightchild);
        }
        return;
    }
    int main(){
        int n;
        while(scanf("%d",&n) != EOF){
            TreeNode* root = NULL;
            while(n--){
                int x;
                scanf("%d",&x);
                root = Insert(root,x);
            }
            InOrder(root);
        }
        return 0;
    }
    
    
    展开全文
  • 文章目录线索二叉树的结构及数据类型定义根据输入结点初始化二叉树中序遍历二叉树并线索化遍历中序线索二叉树项目完整代码运行效果图线索二叉树的结构及数据类型定义//定义数据类型typedef char ElemType;...
  • c++二叉排序树+中序遍历

    千次阅读 2012-12-19 16:57:00
    尽管二叉排序树很简单,但是第次写二叉排序树的类, 还是有一点的麻烦。 不知道如何写递归,如何写成员函数等。。。 第次总是会很纠结的,所以发篇博文来纪念下自己写的 第个C++类 BY Mr_Zys */ #include ...
  • 二叉搜索树(Binary Search Tree),(又:二叉搜索树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根节点的值; 若它的右子树不空,则右子树...
  • 我们知道二叉搜索中序遍历就是排序好的数列。所以我们只需中序遍历到第k个,我们就认为得到答案了。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : ...
  • 给定个二叉树,判断它是否是合法的二叉查找(BST) 一棵BST定义为: 节点的左子树中的值要严格小于该节点的值。节点的右子中的值要严格大于该节点的值。左右子树也必须是二叉查找个节点的也是二叉查找...
  • 本文链接:https://blog.csdn.net/m0_37609579/article/details/99687256 、计算机科学中的 二、二叉树的定义 一棵树,它的每个节点最多只能有两个子节点,此时就叫二叉树。(我们一般在书中试题中见到的是...
  • 二叉排序树+中序遍历

    2013-01-16 18:23:31
    #include using namespace std; template struct node{ T num; node* Lnext; node* Rnext; }; template class list{ public: list(); void node_delete(T *p); void node_insert(T *p);
  • 二叉搜索中序遍历(Java)

    千次阅读 2019-03-16 20:34:13
    给出二叉搜索,返回这个中序遍历序列 实现 代码: public List&amp;lt;Integer&amp;gt; inorderTraversal(TreeNode root) { List&amp;lt;Integer&amp;gt; list = new ArrayList&amp;...
  • 二叉排序树建立及中序遍历,数据结构作业
  • 将有序数组转换为二叉搜索中序遍历,递归) https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/ 将个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索。 本题中,个...
  • 给定个二叉树,判断其是否是个有效的二叉搜索。 假设二叉搜索具有如下特征: 节点的左子树只包含小于当前节点的数。 节点的右子只包含大于当前节点的数。 所有左子树和右子自身必须也是二叉搜索...
  • 中序遍历二叉树,如果有一对降序,那么交换这两个节点的值 如果有两降序,那么交换第个降序的第个节点的值和最后个降序的组后个节点值 代码如下: class Solution { public: TreeNode* pre,t1,t2; ...
  • 根据输入数据建造二叉排序树,并中序遍历,从而输出结果
  • 创建二叉排序树,先序遍历,中序遍历,判断是否存在关键点 这是所要创建的二叉排序树,a[10] = {4, 5, 2, 1, 0, 9, 3, 7, 6, 8},请先在草稿纸上画出图形,再看程序 代码实现: #include #include typedef ...
  • 恢复二叉搜索 二叉搜索中的两个节点被错误地交换。 请在不改变其结构的情况下,恢复这棵树。 示例1: 输入: [1,3,null,null,2] 1 / 3 \ 2 输出: [3,1,null,null,2] 3 / ...
  • 文章目录前序遍历、中序遍历、后序遍历的递归和非递归实现C/C++实现 前序遍历、中序遍历、后序遍历的递归和非递归实现 前序遍历顺序:根->左->...然后出栈个节点,中序遍历此时才打印该节点...
  • 对二叉排序树中序遍历(非递归不用栈队列) 找到这树的中序遍历的第个节点 相当于找这课二叉树的最小值 BstNode* First(BstNode* ptr)//找到这树的中序遍历的第个节点 { while (ptr != nullptr &&...
  • 中序遍历时,判断当前节点是否大于中序遍历的前个节点,如果大于,说明满足 BST,继续遍历;否则直接返回 false。 class Solution { #define ll long long public: ll pre=(1LL<<60)*-1; bool isValidBST...
  • 实现个函数,检查一棵二叉树是否为二叉搜索。 示例 1: 输入: 2 / 1 3 输出: true 示例 2: 输入: 5 / 1 4 / 3 6 输出: false 解释: 输入为: [5,1,4,null,null,3,6]。 根节点的值为 5 ,但是其右子节点值为 4 ...
  • 二叉搜索的第k大节点 利用了二叉搜索的性质: 前序遍历是升序的,后序遍历是降序的。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; *...
  • (2) 建立一棵二叉排序树,然后进行中序遍历,并实现动态查找。(输入零为空) 头文件:1.h #include &lt;iostream&gt; #include &lt;malloc.h&gt; #include &lt;string.h&gt; #define TRUE...
  • * 二叉排序树BST的插入和中序遍历 * 排序树的中序遍历输出序列是递增的 **/ #include<iostream> using namespace std; #define DataType int #define test_length 12 DataType test_data[test_length]={5,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,172
精华内容 10,068
关键字:

对一棵二叉排序树进行中序遍历