算法_二叉树

package com.demo.calculate;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;

import com.demo.calculate.bean.BinaryTree;
import com.demo.calculate.bean.TreeNode;

public class TreeActivit extends Activity {
private BinaryTree binaryTree;
@Override
protected void onCreate( Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_tree);
//创建一棵空树
binaryTree = new BinaryTree();
TreeNode root = new TreeNode(1);
binaryTree.setRoot(root);
//根节点的左节点
TreeNode leftNode = new TreeNode(2);
leftNode.setNodeLeft(new TreeNode(4));
leftNode.setNodeRight(new TreeNode(5));
//根节点的右节点
TreeNode rightNode = new TreeNode(3);
rightNode.setNodeLeft(new TreeNode(6));
rightNode.setNodeRight(new TreeNode(7));
root.setNodeLeft(leftNode);
root.setNodeRight(rightNode);

1.png

2.png

3.png

4.png

package com.demo.calculate.bean;

public class BinaryTree {
private int value;
private TreeNode root;
public int getValue() {
return value;
}

public void setValue(int value) {
    this.value = value;
}

public TreeNode getRoot() {
    return root;
}

public void setRoot(TreeNode root) {
    this.root = root;
}

public void frontShow() {
    if (root!=null){
        root.frontShow();
    }
}

public void midShow() {
    if (root!=null){
        root.midShow();
    }

}

public void afterShow() {
    if (root!=null){
        root.afterShow();
    }
}

public TreeNode frontSearch(int i) {
    if (root!=null){
        return root.frontSearch(i);
    }
    return  null;
}

public void deleteNode(int i) {
    if (root!=null){
        root.deleteNode(i);
    }
}

}
package com.demo.calculate.bean;

import android.util.Log;

public class TreeNode {
private int value;
private TreeNode nodeLeft;
private TreeNode nodeRight;
public void setNodeLeft(TreeNode nodeLeft) {
this.nodeLeft = nodeLeft;
}
public void setNodeRight(TreeNode nodeRight) {
this.nodeRight = nodeRight;
}
public TreeNode(int value) {
this.value = value;
}
public void frontShow() {
Log.i("tag",value+"");
if (nodeLeft!=null){
nodeLeft.frontShow();
}
if (nodeRight!=null){
nodeRight.frontShow();
}
}
public int getValue() {
return value;
}

public void setValue(int value) {
    this.value = value;
}

public void midShow() {
    if (nodeLeft!=null){
        nodeLeft.midShow();
    }
    Log.i("tag",value+"");
    if (nodeRight!=null){
        nodeRight.midShow();
    }
}

public void afterShow() {
    if (nodeLeft!=null){
        nodeLeft.afterShow();
    }
    if (nodeRight!=null){
        nodeRight.afterShow();
    }
    Log.i("tag",value+"");
}
//前序查找
public TreeNode frontSearch(int i) {
    TreeNode target=null;
    if (this.value ==i){
        return this;
    }else{
        if (nodeLeft!=null){
            target = nodeLeft.frontSearch(i);
        }
        if (target!=null){
            return target;
        }
        if (nodeRight!=null){
            target = nodeRight.frontSearch(i);
        }
    }
    return target;
}

public void deleteNode(int i) {
    TreeNode parent = this;
    if (this.value==i){
        parent = null;
    }
    //判断左儿子
    if (parent!=null && parent.nodeLeft!=null && parent.nodeLeft.value==i){
        parent.nodeLeft = null;
        return;
    }
    //判断右儿子
    if (parent!=null && parent.nodeRight!=null && parent.nodeRight.value==i){
        parent.nodeRight = null;
        return;
    }
    //递归删除左面的儿子
    parent = nodeLeft;
    if (parent!=null){
        parent.deleteNode(i);
    }
    //递归删除右面的儿子
    parent = nodeRight;
    if (parent!=null){
        parent.deleteNode(i);
    }
}

}