排序二叉树的性质：
java
若是左子树不为空，则左子树上的点都小于根节点。node
若是右子树不为空，则右子树上的点都大于根节点。this
根节点的左子树和右子树都是二叉排序树spa
排序二叉树的添加操做
code
从根节点开始，做为当前节点排序
那当前节点与插入节点的值进行比较
图片若比当前节点大，把当前节点的右子节点做为当前结点，比当前节点的小，将左节点做为当前节点进行比较get
重复2，3步骤直到找到合适的叶子结点class
若比叶子节点大，就插到叶子结点的右子节点，反之插到左子节点二叉树
排序二叉树的删除操做的状况有下面四种
无子节点，直接删除
只有左子树或左节点，将删除节点的左节点做为根节点便可
只有右子树或右节点，将删除节点的右子节点做为根节点
即有右子树，又有左子树，这种状况为了方便本身记忆，我是只采起一种方法，就是采起该删除节点的前驱节点或后继节，来补删除节点的位置。（前驱节点就是比删除节点全部小的节点中里面最大的值，后继节点就是比删除节点都大的节点中的最小点）（2 7 8 10 15 17）例如删除节点是10，则前驱就是8，后继就是15
如图片上的，删除20这个点，能够用前驱15或后继30来做为补位的节点
public class BinarySortTree {
public static class Node {
private int data;
private String name;
private Node leftNode;
private Node rightNode;
private Node parent;
public Node(int data, Node parentNode) {
super();
this.data = data;
this.parent = this.parent;
}
public Node(int data, String name) {
super();
this.data = data;
this.name = name;
}
public Node(int data) {
super();
this.data = data;
}
public Node() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public Node getLeftNode() {
return leftNode;
}
public void setLeftNode(Node leftNode) {
this.leftNode = leftNode;
}
public Node getRightNode() {
return rightNode;
}
public void setRightNode(Node rightNode) {
this.rightNode = rightNode;
}
public Node getParent() {
return parent;
}
public void setParent(Node parent) {
this.parent = parent;
}
}
private Node root;
public Node addNode(Node node){
if(root==null){
root=node;
}else{
Node parent=getNodeIndex(root, node.getData());
node.parent=parent;
if(parent.getData()>node.getData()){
parent.leftNode=node;
}else{
parent.rightNode=node;
}
}
return root;
}
private Node getNodeIndex(Node node,int data){
if(data>=node.getData()){
if(node.getRightNode()==null){
return node;
}else{
return getNodeIndex(node.rightNode, data);
}
}else {
if(node.getLeftNode()==null){
return node;
}else{
return getNodeIndex(node.leftNode, data);
}
}
}
//广度遍历
public void breadth(){
Queue<Node> queue=new ArrayDeque<>();
if(root!=null){
queue.add(root);
while(!queue.isEmpty()){
Node node=queue.poll();
if(node.leftNode!=null)
queue.add(node.leftNode);
if(node.rightNode!=null)
queue.add(node.rightNode);
System.out.print(node.getData()+"-");
}
}
}
//中序遍历
public void middle(){
if(root!=null){
pMiddle(root);
}
}
private void pMiddle(Node node){
if(node!=null){
if(node.leftNode!=null)
{
pMiddle(node.leftNode);
}
System.out.println(node.getData());
if(node.rightNode!=null){
pMiddle(node.rightNode);
}
}
}
public void delete(int data){
if(root!=null){
Node node=search(root, data);
if(node.leftNode==null&node.rightNode==null){
Node parentNode=node.parent;
if(parentNode.leftNode.getData()==data){
parentNode.leftNode=null;
}else {
parentNode.rightNode=null;
}
}
if(node.leftNode==null){
Node parentNode=node.parent;
if(parentNode.leftNode.getData()==data){
parentNode.leftNode=node.rightNode;
}else {
parentNode.rightNode=node.rightNode;
}
}
if(node.rightNode==null){
Node parenNode=node.parent;
if(parenNode.leftNode.getData()==data){
parenNode.leftNode=node.leftNode;
}else{
parenNode.rightNode=node.leftNode;
}
}
//既有右子树，又有作子树
if(node.rightNode!=null&node.leftNode!=null){
Node preNode=findPreNode(node);
Node preParentNode=preNode.parent;
if(preParentNode.leftNode.getData()==preNode.getData()){
preParentNode.leftNode=null;
}else{
preParentNode.rightNode=null;
}
preNode.rightNode=node.rightNode;
node.rightNode.parent=preNode;
preNode.leftNode=node.leftNode;
node.leftNode.parent=preNode;
Node parentNode=node.parent;
parentNode.rightNode=preNode;
}
}
}
/**
* 查找某个点的前驱节点
* @param node
* @return
*/
private Node findPreNode(Node node){
Node rightSonNode=node.leftNode;
while(rightSonNode.rightNode!=null){
rightSonNode=rightSonNode.rightNode;
}
return rightSonNode;
}
/**
* 从根节点开始查找节点
* @param node
* @param data
* @return
*/
public Node search(Node node,int data){
if(data==node.getData())
return node;
if(data>node.getData()){
if(node.rightNode!=null){
return search(node.rightNode, data);
}else{
return null;
}
}else{
if(node.leftNode!=null){
return search(node.leftNode, data);
}else{
return null;
}
}
}
public static void main(String[] args) {
BinarySortTree tree=new BinarySortTree();
tree.addNode(new Node(5));
tree.addNode(new Node(20));
tree.addNode(new Node(10));
tree.addNode(new Node(3));
tree.addNode(new Node(8));
tree.addNode(new Node(15));
tree.addNode(new Node(30));
tree.middle();
tree.delete(20);
tree.middle();
}
}