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

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


    展开全文
  • 对二叉排序树中序遍历(非递归不用栈队列) 找到这棵树的中序遍历的第一个节点 相当于找这课二叉树的最小值 BstNode* First(BstNode* ptr)//找到这棵树的中序遍历的第一个节点 { while (ptr != nullptr &&...

    对二叉排序树中序遍历(非递归不用栈队列)

    在这里插入图片描述
    找到这棵树的中序遍历的第一个节点
    相当于找这课二叉树的最小值

    BstNode* First(BstNode* ptr)//找到这棵树的中序遍历的第一个节点 
    {
    	while (ptr != nullptr && ptr->leftchild != nullptr)
    	{
    		ptr = ptr->leftchild;
    	}
    	return ptr;
    }
    

    找到这棵树的中序遍历的最后一个节点
    相当于找这棵二叉树的最大值

    BstNode* Last(BstNode* ptr)//找到这棵树的中序遍历的最后一个节点 
    {
    	while (ptr != nullptr && ptr->rightchild != nullptr)
    	{
    		ptr = ptr->rightchild;
    	}
    	return ptr;
    }
    

    非递归不用栈队列的中序遍历

    void NiceInOrder(BstNode* ptr)
    {
    	for (BstNode* p = First(ptr); p != nullptr; p = Next(p))
    	{
    		cout << p->key << " ";
    	}
    	cout << endl;
    }	
    

    如何书写Next函数(中序遍历的后继)?

    迭代器方案
    在这里插入图片描述

    我们的9是17的左孩子,23是45的左孩子,45和17之间是右孩子关系,把45给17,17给给根节点。

    最开始的时候ptr指向09结点,pa指向17
    然后pa=ptr

    BstNode* Next(BstNode* ptr)//寻找中序遍历的后继 
    {
    	if (ptr == nullptr) return nullptr;
    	if (ptr->rightchild != nullptr)
    	{
    		return First(ptr->rightchild);
    	}
    	else
    	{
    		BstNode* pa = ptr->parent;
    		while (pa != nullptr && pa->leftchild != ptr)
    		{
    			ptr = pa;
    			pa = ptr->parent;
    		}
    		return pa;
    	}
    }
    

    逆向迭代方案

    void ResNiceInOrder(BstNode* ptr)
    {
    	for (BstNode* p = Last(ptr); p != nullptr; p = Prev(p))
    	{
    		cout << p->key << " ";
    	}
    	cout << endl;
    }
    

    如何书写Prev函数(中序遍历的前驱)?

    BstNode* Prev(BstNode* ptr)
    {
    	if (ptr == nullptr) return nullptr;
    	if (ptr->leftchild != nullptr)
    	{
    		return Last(ptr->leftchild);
    	}
    	else
    	{
    		BstNode* pa = ptr->parent;
    		while (pa != nullptr && pa->rightchild != ptr)
    		{
    			ptr = pa;
    			pa = ptr->parent;
    		}
    		return pa;
    	}
    }
    

    在没有双亲的二叉排序树中用中序遍历

    在这里插入图片描述
    实际上就是把二叉树改装为中序遍历的二叉链表
    在这里插入图片描述
    把左孩子当做前驱看待,把右孩子当做后继来看待
    9的前驱变为空,9的后继指向17。17的前驱指向9,17的后继指向23,23 的前驱指向17,23的后继指向45。
    就地转化成双链表,不存在插入和删除操作

    BstNode * InOrderList(BstNode* ptr)//中序的二叉链表
    {
    	if (ptr == nullptr) return nullptr;
    	stack<BstNode*> st;
    	BstNode* newroot = nullptr;//根要发生改变
    	BstNode* pre = nullptr;//定义前驱
    	while (ptr != nullptr || !st.empty())
    	{
    		while (ptr != nullptr)
    		{
    			st.push(ptr);
    			ptr = ptr->leftchild;
    		}
    		ptr = st.top(); st.pop();
    		if (pre == nullptr)//中序遍历的是第一个结点
    		{
    			newroot = ptr;
    			pre = ptr;
    		}
    		else
    		{
    			pre->rightchild = ptr;
    			ptr->leftchild = pre;
    			pre = ptr;
    		}
    		ptr = ptr->rightchild;
    	}
    	return newroot;
    }
    

    插入函数

    bool Insert(BstNode*& ptr, KeyType kx)
    {
    	if (ptr == nullptr)
    	{
    		ptr = Buynode(kx);
    		return true;
    	}
    	BstNode* pa = nullptr;
    	BstNode* p = ptr;
    	while (p != nullptr && p->key != kx)
    	{
    		pa = p;
    		p = kx < p->key ? p->leftchild : p->rightchild;
    	}
    	if (p != nullptr && p->key == kx) return false;
    	p = Buynode(kx);
    	if (p->key < pa->key)
    	{
    		pa->leftchild = p;
    	}
    	else
    	{
    		pa->rightchild = p;
    	}
    	return true;
    }
    
    展开全文
  • 创建二叉排序树,先序遍历,中序遍历,判断是否存在关键点 这是所要创建的二叉排序树,a[10] = {4, 5, 2, 1, 0, 9, 3, 7, 6, 8},请先在草稿纸上画出图形,再看程序 代码实现: #include #include typedef ...

    创建二叉排序树,先序遍历,中序遍历,判断是否存在关键点

    这是所要创建的二叉排序树,a[10] = {4, 5, 2, 1, 0, 9, 3, 7, 6, 8},请先在草稿纸上画出图形,再看程序

    代码实现:

    #include <stdio.h>
    #include <stdlib.h>
    typedef struct BTNode{
    	int key,cout;
    	struct BTNode *lchild;
    	struct BTNode *rchild;
    }BTNode;
    //创建二叉排序树 
    bool BSTInsert(BTNode *&bt,int x){
    	if(bt==NULL){
    		bt=(BTNode*)malloc(sizeof(BTNode));
    		bt->key=x;
    		bt->lchild=bt->rchild=NULL;
    		return true;
    	}
    	if(x==bt->key)
    		return false;
    	 if(x>bt->key)
    		return BSTInsert(bt->rchild,x);
    	 else
    		return BSTInsert(bt->lchild,x);
    }
    //先序遍历 
    void PreOrderTraverse(BTNode *bt){
    	if(bt){
    		printf("%d ",bt->key);
    		PreOrderTraverse(bt->lchild);
    		PreOrderTraverse(bt->rchild);
    	}
    }//中序遍历 
    void InOrderTraverse(BTNode *bt){
    	if(bt){
    		InOrderTraverse(bt->lchild);
    		printf("%d ",bt->key);
    		InOrderTraverse(bt->rchild);
    	}
    }
    //查找关键点是否存在 
    bool BSTSearch(BTNode *bt,int x){//找到关键字返回1,否则返回0 
    	if(!bt){
    		return 0;
    	}
    	else{
    		if(bt->key==x)
    			return 1;
    		else if(bt->key>x)
    			return BSTSearch(bt->lchild,x);
    		else
    			return BSTSearch(bt->rchild,x);
    	}
    }
    int main(int argc, char *argv[])
    {
    	int i,a[10] = {4, 5, 2, 1, 0, 9, 3, 7, 6, 8}; 
    	struct BTNode *bt=NULL;
    	for(i=0;i<10;++i){
    		BSTInsert(bt,a[i]);
    	}
    	printf("%d\n",BSTSearch(bt,6));
    	printf("先序遍历:"); 
    	PreOrderTraverse(bt);
    	printf("\n中序遍历:");
    	InOrderTraverse(bt); 
    	printf("\n");
    	return 0;
    }
    输出结果:

    1
    先序遍历:4 2 1 0 3 5 9 7 6 8
    中序遍历:0 1 2 3 4 5 6 7 8 9
    请按任意键继续. . .
    



    展开全文
  • 我们知道二叉搜索中序遍历就是排序好的数列。所以我们只需中序遍历到第k个,我们就认为得到答案了。 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : ...
  • * 二叉排序树BST的插入和中序遍历 * 排序树的中序遍历输出序列是递增的 **/ #include<iostream> using namespace std; #define DataType int #define test_length 12 DataType test_data[test_length]={5,...
  • 文章目录前序遍历、中序遍历、后序遍历的递归和非递归实现C/C++实现 前序遍历、中序遍历、后序遍历的递归和非递归实现 前序遍历顺序:根->左->右。 中序遍历顺序:左->根->右。 后序遍历顺序:左->右-&...
  • 实现要求: ...该二叉树类提供方法进行节点的追加(追加节点时,构建二叉排序树),并提 供中序遍历二叉树节点的方法。 BinaryTreeNode类 public class BinaryTreeNode { private int data; priv...
  • #include <iostream> #include <cstdio> #include <queue> using namespace std;...struct TreeNode{ ...TreeNode* Insert(TreeNode* root, int x){//二叉排序树建树 if(root == NULL){
  • 将有序数组转换为二叉搜索中序遍历,递归) https://leetcode-cn.com/problems/convert-sorted-array-to-binary-search-tree/ 将一个按照升序排列的有序数组,转换为一棵高度平衡二叉搜索。 本题中,一个...
  • 二叉搜索树(Binary Search Tree),(又:二叉搜索树,二叉排序树)它或者是一棵空树,或者是具有下列性质的二叉树: 若它的左子树不空,则左子树上所有结点的值均小于它的根节点的值; 若它的右子树不空,则右子树...
  • c++二叉排序树+中序遍历

    千次阅读 2012-12-19 16:57:00
    /* cpp 二叉排序树 尽管二叉排序树很简单,但是第一次写二叉排序树的类, 还是有一点的麻烦。 不知道如何写递归,如何写成员函数等。。。 第一次总是会很纠结的,所以发篇博文来纪念下自己写的 第一个C++类 BY ...
  • 完全二叉树的层序中(从1开始),根为root,左子树若存在则为2*root,右子树为2*root+1。...二叉排序树的中序序列是非递减的,sort以后即可得到中序序列。结合中序遍历,第一次执行到visit(root)是最小的结...
  • 二叉搜索中序遍历(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;...
  • 验证二叉搜索 给定一个二叉树,判断其是否是一个有效的二叉搜索。 假设一个二叉搜索具有如下特征: 节点的左子树只包含小于当前节点的数。 节点的右子只包含大于当前节点的数。 所有左子树和右子自身必须...
  • 二叉排序树创建、中序遍历(由小到大)、交换左右子树输出(由大到小),完整C++实现代码,在Clion中编译通过。 #include "stdio.h" #include "stdlib.h" #include "malloc.h" //...
  • 文章目录线索二叉树的结构及数据类型定义根据输入结点初始化二叉树中序遍历二叉树并线索化遍历中序线索二叉树项目完整代码运行效果图线索二叉树的结构及数据类型定义//定义数据类型typedef char ElemType;...
  • 给定一个二叉树,判断它是否是合法的二叉查找(BST) 一棵BST定义为: 节点的左子树中的值要严格小于该节点的值。节点的右子中的值要严格大于该节点的值。左右子树也必须是二叉查找。一个节点的也是二叉查找...
  • } //查看树中的值 System.out.println("二叉排序树中序遍历:"); bst.midShow(); System.out.println(); System.out.println("============="); Node node = bst.search(10); System.out.println(node.value); Node...
  • 恢复二叉搜索 二叉搜索中的两个节点被错误地交换。 请在不改变其结构的情况下,恢复这棵。 示例1: 输入: [1,3,null,null,2] 1 / 3 \ 2 输出: [3,1,null,null,2] 3 / ...
  • * 中序遍历 * @param root */ public static void inOrder(BinaryTree root){ if(root == null){ return; } if(root.getLeft() != null){ preOrder(root.getLeft()); } //遍历出数据 ...
  • 中序遍历二叉排序树

    2018-06-30 21:06:55
    中序遍历二叉排序树 输入一整数序列,建立二叉排序树,然后中序遍历。 输入说明 输入第一行为整数的个数n,第二行是具体的n个整数。 输出说明 建立二叉排序树,然后输出中序遍历的结果。 输入样例 5 1 6 5 9 8 ...
  • 三种遍历方式的分类是以根节点所在位置来划分的,以下图示例 前序遍历:8、5、3、6、14、9、16 中序遍历:3、5、6、8、9、14、16 后序遍历:3、6、5、9、16、14、8...排序:根据以上示例可得遍历一般使用中序遍历 ...
  • 中序遍历时,判断当前节点是否大于中序遍历的前一个节点,如果大于,说明满足 BST,继续遍历;否则直接返回 false。 class Solution { #define ll long long public: ll pre=(1LL<<60)*-1; bool isValidBST...

空空如也

空空如也

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

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