Java二叉排序树

一、二叉排序树定义

1.二叉排序树的定义

　　二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：
①若它的左子树非空，则左子树上所有结点的值均小于根结点的值；
②若它的右子树非空，则右子树上所有结点的值均大于根结点的值；
③左、右子树本身又各是一棵二叉排序树。

上述性质简称二叉排序树性质(BST性质)，故二叉排序树实际上是满足BST性质的二叉树。

2.二叉排序树的性质
按中序遍历二叉排序树，所得到的中序遍历序列是一个递增有序序列。

3.二叉排序树的插入
在二叉排序树中插入新结点，要保证插入后的二叉树仍符合二叉排序树的定义。 　　
插入过程：
若二叉排序树为空，则待插入结点*S作为根结点插入到空树中； 　　
当非空时，将待插结点关键字S->key和树根关键字t->key进行比较，若s->key = t->key,则无须插入，若s->key< t->key,则插入到根的左子树中，若s->key> t->key,则插入到根的右子树中。而子树中的插入过程和在树中的插入过程相同，如此进行下去，直到把结点*s作为一个新的树叶插入到二叉排序树中，或者直到发现树已有相同关键字的结点为止。

4.二叉排序树的查找
假定二叉排序树的根结点指针为 root ，给定的关键字值为 K ，则查找算法可描述为：
　　① 置初值： q ＝ root ；
　　② 如果 K ＝ q －＞ key ，则查找成功，算法结束；
　　③ 否则，如果 K ＜ q －＞ key ，而且 q 的左子树非空，则将 q 的左子树根送 q ，转步骤②；否则，查找失败，结束算法；
　　④ 否则，如果 K ＞ q －＞ key ，而且 q 的右子树非空，则将 q 的右子树根送 q ，转步骤②；否则，查找失败，算法结束。

5.二叉排序树的删除
假设被删结点是*p，其双亲是*f，不失一般性，设*p是*f的左孩子，下面分三种情况讨论： 　　
⑴ 若结点*p是叶子结点，则只需修改其双亲结点*f的指针即可。 　　
⑵ 若结点*p只有左子树PL或者只有右子树PR，则只要使PL或PR 成为其双亲结点的左子树即可。 　　
⑶ 若结点*p的左、右子树均非空，先找到*p的中序前趋(或后继)结点*s（注意*s是*p的左子树中的最右下的结点，它的右链域为空），然后有两种做法：① 令*p的左子树直接链到*p的双亲结点*f的左链上,而*p的右子树链到*p的中序前趋结点*s的右链上。② 以*p的中序前趋结点*s代替*p（即把*s的数据复制到*p中），将*s的左子树链到*s的双亲结点*q的左（或右）链上。

6、二叉树的遍历

二叉树的遍历有三种方式，如下：
（1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。
（2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。
（3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。

二、代码编写

1、树节点类的定义

package com.lin;
/**
 * 功能概要：
 *
 * @author linbingwen
 * @since  2015年8月29日
 */
public class TreeNode {

	public Integer data;

	/*该节点的父节点*/
	public TreeNode parent;

	/*该节点的左子节点*/
	public TreeNode left;

	/*该节点的右子节点*/
	public TreeNode right;

	public TreeNode(Integer data) {
		this.data = data;

	}

	@Override
	public String toString() {
		return "TreeNode [data=" + data + "]";
	}

}

2、二叉排序树的定义

package com.lin;

/**
 * 功能概要：排序/平衡二叉树
 *
 * @author linbingwen
 * @since  2015年8月29日
 */
public class SearchTree {

     public TreeNode root;

     public long size;

	/**
	 * 往树中加节点
	 * @author linbingwen
	 * @since  2015年8月29日
	 * @param data
	 * @return Boolean 插入成功返回true
	 */
	public Boolean addTreeNode(Integer data) {

		if (null == root) {
			root = new TreeNode(data);
			System.out.println("数据成功插入到平衡二叉树中");
			return true;
		}

		TreeNode treeNode = new TreeNode(data);// 即将被插入的数据
		TreeNode currentNode = root;
		TreeNode parentNode;

		while (true) {
			parentNode = currentNode;// 保存父节点
			// 插入的数据比父节点小
			if (currentNode.data > data) {
				currentNode = currentNode.left;
				// 当前父节点的左子节点为空
				if (null == currentNode) {
					parentNode.left = treeNode;
					treeNode.parent = parentNode;
					System.out.println("数据成功插入到二叉查找树中");
					size++;
					return true;
				}
				// 插入的数据比父节点大
			} else if (currentNode.data < data) {
				currentNode = currentNode.right;
				// 当前父节点的右子节点为空
				if (null == currentNode) {
					parentNode.right = treeNode;
					treeNode.parent = parentNode;
					System.out.println("数据成功插入到二叉查找树中");
					size++;
					return true;
				}
			} else {
				System.out.println("输入数据与节点的数据相同");
				return false;
			}
		}
	}

	/**
	 * 查找数据
	 * @author linbingwen
	 * @since  2015年8月29日
	 * @param data
	 * @return TreeNode
	 */
	public TreeNode findTreeNode(Integer data){
		if(null == root){
			return null;
		}
		TreeNode current = root;
		while(current != null){
			if(current.data > data){
				current = current.left;
			}else if(current.data < data){
				current = current.right;
			}else {
				return current;
			}

		}
		return null;
	}

}

这里暂时只放了一个增加和查找的方法

3、前、中、后遍历

package com.lin;

import java.util.Stack;

/**
 * 功能概要：
 *
 * @author linbingwen
 * @since  2015年8月29日
 */
public class TreeOrder {

    /**
     * 递归实现前序遍历
     * @author linbingwen
     * @since  2015年8月29日
     * @param treeNode
     */
	public static void preOrderMethodOne(TreeNode treeNode) {
		if (null != treeNode) {
			System.out.print(treeNode.data + "  ");
			if (null != treeNode.left) {
				preOrderMethodOne(treeNode.left);
			}
			if (null != treeNode.right) {
				preOrderMethodOne(treeNode.right);

			}
		}
	}

	/**
	 * 循环实现前序遍历
	 * @author linbingwen
	 * @since  2015年8月29日
	 * @param treeNode
	 */
	public static void preOrderMethodTwo(TreeNode treeNode) {
		if (null != treeNode) {
			Stack<TreeNode> stack = new Stack<TreeNode>();
			stack.push(treeNode);
			while (!stack.isEmpty()) {
				TreeNode tempNode = stack.pop();
				System.out.print(tempNode.data + "  ");
				// 右子节点不为null,先把右子节点放进去
				if (null != tempNode.right) {
					stack.push(tempNode.right);
				}
				// 放完右子节点放左子节点，下次先取
				if (null != tempNode.left) {
					stack.push(tempNode.left);
				}
			}
		}
	}

	/**
	 * 递归实现中序遍历
	 * @author linbingwen
	 * @since  2015年8月29日
	 * @param treeNode
	 */
	public static void medOrderMethodOne(TreeNode treeNode){
		if (null != treeNode) {
			if (null != treeNode.left) {
				medOrderMethodOne(treeNode.left);
			}
			System.out.print(treeNode.data + "  ");
			if (null != treeNode.right) {
				medOrderMethodOne(treeNode.right);
			}
		}

	}

	/**
	 * 循环实现中序遍历
	 * @author linbingwen
	 * @since  2015年8月29日
	 * @param treeNode
	 */
	public static void medOrderMethodTwo(TreeNode treeNode){
		Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode current = treeNode;
        while (current != null || !stack.isEmpty()) {
            while(current != null) {
                stack.push(current);
                current = current.left;
            }
            if (!stack.isEmpty()) {
                current = stack.pop();
                System.out.print(current.data+"  ");
                current = current.right;
            }
        }
	}

    /**
     * 递归实现后序遍历
     * @author linbingwen
     * @since  2015年8月29日
     * @param treeNode
     */
	public static void postOrderMethodOne(TreeNode treeNode){
		if (null != treeNode) {
			if (null != treeNode.left) {
				postOrderMethodOne(treeNode.left);
			}
			if (null != treeNode.right) {
				postOrderMethodOne(treeNode.right);
			}
			System.out.print(treeNode.data + "  ");
		}

	}

	/**
	 * 循环实现后序遍历
	 * @author linbingwen
	 * @since  2015年8月29日
	 * @param treeNode
	 */
	public static void postOrderMethodTwo(TreeNode treeNode){
		if (null != treeNode) {
			Stack<TreeNode> stack = new Stack<TreeNode>();
			TreeNode current = treeNode;
			TreeNode rightNode = null;
			while(current != null || !stack.isEmpty()) {
	            while(current != null) {
	                stack.push(current);
	                current = current.left;
	            }
	            current = stack.pop();
	            while (current != null && (current.right == null ||current.right == rightNode)) {
	                System.out.print(current.data + "  ");
	                rightNode = current;
	                if (stack.isEmpty()){
	                    System.out.println();
	                    return;
	                }
	                current = stack.pop();
	            }
	            stack.push(current);
	            current = current.right;
	        }  

		}
	}

}

4、使用方法

package com.lin;

/**
 * 功能概要：
 *
 * @author linbingwen
 * @since  2015年8月29日
 */
public class SearchTreeTest {

	/**
	 * @author linbingwen
	 * @since  2015年8月29日
	 * @param args
	 */
	public static void main(String[] args) {
		SearchTree tree = new SearchTree();
		tree.addTreeNode(50);
		tree.addTreeNode(80);
		tree.addTreeNode(20);
		tree.addTreeNode(60);
		tree.addTreeNode(10);
		tree.addTreeNode(30);
		tree.addTreeNode(70);
		tree.addTreeNode(90);
		tree.addTreeNode(100);
		tree.addTreeNode(40);
		System.out.println("=============================="+"采用递归的前序遍历开始"+"==============================");
		TreeOrder.preOrderMethodOne(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用循环的前序遍历开始"+"==============================");
		TreeOrder.preOrderMethodTwo(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用递归的后序遍历开始"+"==============================");
		TreeOrder.postOrderMethodOne(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用循环的后序遍历开始"+"==============================");
		TreeOrder.postOrderMethodTwo(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用递归的中序遍历开始"+"==============================");
		TreeOrder.medOrderMethodOne(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用循环的中序遍历开始"+"==============================");
		TreeOrder.medOrderMethodTwo(tree.root);

	}

}

输出结果：

同样，进行查找过程如下：

		TreeNode node = tree.findTreeNode(100);
		System.out.println(node);

结果是正确的

版权声明：本文为博主林炳文Evankaka原创文章，转载请注明出处http://blog.csdn.net/evankaka

时间： 2024-10-11 06:05:53

Java二叉排序树的相关文章

Java二叉排序树（转）

一.二叉排序树定义 1.二叉排序树的定义 二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree).其定义为:二叉排序树或者是空树,或者是满足如下性质的二叉树:①若它的左子树非空,则左子树上所有结点的值均小于根结点的值:②若它的右子树非空,则右子树上所有结点的值均大于根结点的值:③左.右子树本身又各是一棵二叉排序树. 上述性质简称二叉排序树性质(BST性质),故二叉排序树实际上是满足BST性质的二叉树. 2.二叉排序树的性质按中序遍历二叉排序树

Java实现二叉排序树的插入、查找、删除

import java.util.Random; /** * 二叉排序树(又称二叉查找树) * (1)可以是一颗空树 * (2)若左子树不空,则左子树上所有的结点的值均小于她的根节点的值 * (3)若右子树不空,则右子树上所有的结点的值均大于她的根节点的值 * (4)左.右子树也分别为二叉排序树 * * * 性能分析: * 查找性能: * 含有n个结点的二叉排序树的平均查找长度和树的形态有关, * (最坏情况)当先后插入的关键字有序时,构成的二叉排序树蜕变为单枝树.查找性能为O(n) * (最好

【LeetCode-面试算法经典-Java实现】【109-Convert Sorted List to Binary Search Tree（排序链表转换成二叉排序树）】

[109-Convert Sorted List to Binary Search Tree(排序链表转换成二叉排序树)] [LeetCode-面试算法经典-Java实现][全部题目文件夹索引] 原题 Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST. 题目大意 给定一个升序的单链表.将它转换成一颗高度平衡的二叉树 解题思路 解法

java实现二叉排序树

什么是二叉排序树:二叉排序树或者是一颗空树,或者具有以下性质的二叉树: (1)若它的左子树不为空,则左子树上的所有节点的值都小于他的父节点的值: (2)若它的右子树不为空,则右子树上的所有节点的值都大于他的父节点的值: (3)它的左右子树也分别为二叉排序树: java实例: package com.test.linked; public class HeapSort { public class Node{ private int data; private Node leftChildren;

数据结构 Java版二叉排序树

二叉搜索树,又称为二叉查找树和二叉搜索树.它或者是一颗空树,或者具有下列性质的二叉树. 1 若它的左子树不空,则左子树上所有结点的值均小于它的根结点的值. 2 若它的右子树不空,则右子树上所有结点的值均大于或等于它的根结点的值. 3 它的左.右子树也都为二叉搜索树. 构造一颗二叉搜索树,目的不是为了排序,而是为了提高查找.插入和删除关键字的速度.一个有序数据集上的查找速度总是要快于无序数据集,而二叉搜索树这种非线性的结构,也有利于插入和删除的实现. 二叉搜索树的查找性能取决于二叉搜索树的形状,问

二叉排序树java实现

二叉排序树java实现 二叉树排序树是什么? 二叉排序树(Binary Sort Tree)又称二叉查找树.二叉搜索树. 它或者是一棵空树:或者是具有下列性质的二叉树: 若左子树不空,则左子树上所有结点的值均小于它的根结点的值: 若右子树不空,则右子树上所有结点的值均大于它的根结点的值: 左.右子树也分别为二叉排序树: 二叉排序树节点的定义 package tree; public class TreeNode { private int data;//数据 private TreeNode l

java数据结构和算法------二叉排序树

1 package iYou.neugle.search; 2 3 public class BSTree_search { 4 class BSTree { 5 public int data; 6 public BSTree left; 7 public BSTree right; 8 } 9 10 public static void main(String[] args) { 11 BSTree_search bst = new BSTree_search(); 12 int[] arr

AVL二叉排序树的java实现

这两天终于把AVL树好好理解了下,在<算法分析与设计基础>这本书中,被安排在变治法章节,是实例简化思想在查找树中的应用.它对平衡的要求是:每个节点的左右子树的高度差不超过1.从而我们只要在插入或删除节点时,保证这种平衡就可以了.如果平衡被打破,使用一系列旋转使树重新达到平衡. 总共有四种类型的旋转:左单转,右单转,左右双转,右左双转.只要讲到AVL树的算法书都会有旋转的解释.两个单转之间.两个双转之间相互对称.看似复杂的双转,其思想是先转换成单转,从而通过单转实现重新平衡.所以四种旋转的实现可

LeetCode108_Convert SortedArray to BinarySearchTree(将有序数组转成二叉排序树) Java题解

题目: Given an array where elements are sorted in ascending order, convert it to a height balanced BST. 题解: 和我上面一篇将有序链表转成二叉排序树中用哈希表解的方法是一样的.基本思路:链表中间那个节点为树的根节点.根节点的左子树节点应该是根节点左边那部分的中间节点,根节点的右节点应该是根节点右边那部分链表的中间节点.后面就依照这个规律依次类推了. public static TreeNode s