用python和java编写二叉树排序

一、思维预备

1、包装和拆包

包装：将基本数据类型或者没有属性或者功能的对象传换成或者装饰成具有一定的属性和功能的实用类或者包装类。

拆包：包装类或者实用类转化成基本数据类型。

2、指针或者引用

指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

本文将一个内存空间里或者变量单元里存储另一个内存空间的地址。换句话说该变量空间引用另一个内存空间的数据或者对象。

3、二叉树存储结构（二叉树的形成过程）

二叉树是一种特殊的顺序树，它规定有左右两个孩子，即左右孩子顺序不能替换，本文就把左边的孩子比结点小，右边的比结点大。

二叉树数据存储结构下面是理解的二叉树的存储结构（这些都是个人理解所得，有所偏差，如果感到错误请联系博主）；

注意：

1、一个结点只决定它的左右结点的顺序，并且左右结点的数据的位置只与它有关。

2、数据的顺序也与数据的添加顺序有关。换句话说二叉树整体看着无序，局部有序。二叉树排序最后结果还与遍历的方式有关。

3、数据的内存地址可以为空，相当于下面没有数据

4、二叉树中只要有左右孩子（左右结点）的结点。它们三个或者两个的大小关系必须一致。比如一个结点的左结点总比它大，右结点总比它小。次序不能颠倒。

实现方式：递归方式

4、二叉树的遍历方式

叶结点：该节点没有左子树和右子树。

根结点：该节点必须有左子树或者右子树。

遍历即将树的所有结点访问且仅访问一次。按照根节点位置的不同分为前序遍历，中序遍历，后序遍历。

前序遍历：根节点->左子树->右子树 

中序遍历：左子树->根节点->右子树

后序遍历：左子树->右子树->根节点

遍历实现方式：

1、递归实现

2、非递归实现

因为当遍历过根节点之后还要回来，所以必须将其存起来。考虑到后进先出的特点，选用栈存储。数量确定，以顺序栈存储。

3、迭代器实现

二、代码实现

思考：按照上述的知识点介绍完全可以将数据进行包装，使其具有数据，左结点，和右结点（左右结点存的都是对象的引用），可以把这三个看做一个单元。为了保证每个单元之间的联系，用内部类来实现。

1、python代码

#封装结点
class Node:
    __left=None
    __right=None
    __data=None
    __isdelete=False
    def set__isdelete(self,delete):
        self.__isdelete=delete
    def get__data(self):
        return self.__data
    def get__left(self):
        return self.__left
    def get__right(self):
        return self.__right
    def get__isdelete(self):
        return self.__isdelete
    def set__data(self):
        return self.__data
    #初始化数据
    def __init__(self,data=None):
        self.__data=data

    #追加数据
    def append(self,data=None):
        if self.__data > data:
            if self.__left is None:
                self.__left=Node(data)
            else:
                self.__left.append(data)
        elif self.__data< data:
            if self.__right is None:
                self.__right=Node(data)
            else:
                self.__right.append(data)
        else:
            print('插入重复的数据：',data)
    #中遍历，打印数据,注意：递归一定要有一个终止条件，并且必须能够终止递归
    def inorder(self):
        if self.__left is not None:
            self.__left.inorder()
        if self.__isdelete==False:
            print(self.__data)
        if self.__right is not None:
            self.__right.inorder()


#包装结点
class packNode:
    root=None
    currentNode=None
    def __init__(self,data=None):
        self.root=Node(data)
        self.currentNode=self.root
    #追加数据
    def append(self,data=None):
        self.root.append(data)
    #遍历数据
    def inorder(self):
        self.root.inorder();
    #查询数据
    def search(self,data):
        node=self.root
        while True:
            if node is not None:
                if node.get__data() ==data:
                    print("已查到数据：",node.get__data())
                    return  node
                elif node.get__data()<data:
                    node=node.get__right()
                else:
                    node=node.get__left()

    #删除数据
    def delete(self,data):
        result=self.search(data)
        if result is None:
            print('删除失败！')
        else:
            result.set__isdelete(True)
            print('删除成功！')

    #修改数据
    def modify(self,old,new):
        result=self.search(old)
        if result is not None:
            if result.get__isdelete() ==False:
                result.set__data(new)
                print('修改成功！')
            else:
                print('修改失败！')
        else:
            print('修改失败')
bTree = packNode(6)
bTree.append(12)
bTree.append(2)
bTree.append(22)
bTree.append(5)
bTree.append(34)
bTree.append(7)
bTree.append(9)
bTree.append(30)
bTree.append(1)
#输出
bTree.inorder()
#查找
bTree.search(9)
# #删除
bTree.delete(1)
# #修改
bTree.modify(56,78)

结果如下：

1
2
5
6
7
9
12
22
30
34
已查到数据： 9
已查到数据： 1
删除成功！
2、java实现

public class TreeNode {
//    左指针结点
    TreeNode leftTreeNode;
//    右指针结点
    TreeNode rightTreeNode;
//    数据
    private int value;
//判断是否被删除
    private boolean isDelete=false;
    
    
    public boolean isDelete() {
        return isDelete;
    }

    public void setDelete(boolean isDelete) {
        this.isDelete = isDelete;
    }

    public TreeNode(TreeNode leftTreeNode, TreeNode rightTreeNode, int value) {
        super();
        this.leftTreeNode = leftTreeNode;
        this.rightTreeNode = rightTreeNode;
        this.value = value;
        this.isDelete=false;
    }
    
    public TreeNode(int value) {
        this(null,null,value);
    }
    

    public TreeNode() {
        super();
    }

    public TreeNode getLeftTreeNode() {
        return leftTreeNode;
    }
    public void setLeftTreeNode(TreeNode leftTreeNode) {
        this.leftTreeNode = leftTreeNode;
    }
    public TreeNode getRightTreeNode() {
        return rightTreeNode;
    }
    public void setRightTreeNode(TreeNode rightTreeNode) {
        this.rightTreeNode = rightTreeNode;
    }
    public int getvalue() {
        return value;
    }
    public void setvalue(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "TreeNode [leftTreeNode=" + leftTreeNode + ", rightTreeNode=" + rightTreeNode + ", value=" + value + "]";
    }

    
    
    

}

public class BinaryTree {
//    根结点
    private TreeNode root;

    public TreeNode getRoot() {
        return root;
    }

    public void setRoot(TreeNode root) {
        this.root = root;
    }
    /**
     *查数据结点、如果要根结点的数比所要查找的数大，与右结点的数比较，如果要根结点的数比所要查找的数小，与左结点的数比较
     */
    public TreeNode search(int key){
        TreeNode currentNode=root;
    if(currentNode!=null){
            while(currentNode.getvalue()!=key){
                if(currentNode.getvalue()<key){
                    currentNode=currentNode.getRightTreeNode();
                }else{
                    currentNode=currentNode.getLeftTreeNode();
                }
                if(currentNode ==null){
                    return null;
                }
            }
            if(currentNode.isDelete()==true){
                return null;
            }else{
                return currentNode;
            }
        }else{
            return null;
        }
        

    }
    /**
     * 修改数据结点
     */
    public void replace(int oldNum,int newNum){
        TreeNode oldNode=search(oldNum);
        if(oldNode!=null && oldNode.isDelete()==false){
            oldNode.setvalue(newNum);
        }else{
            
            System.out.println("没有查找到该数据！");
        }
    }
    /**
     * 删除结点
     */
    public void delete(TreeNode treeNode,int value){
        TreeNode node=search(value);
        if(node!=null && node.isDelete()==false){
            node.setDelete(true);
            
        }else{
            System.out.println("没有查找到该数据！");
        }
    }
    
    /**
     * 添加数据结点
     */
    public void add(int value){
//        将新增加进行用TreeNode进行包装
        TreeNode newTreeNode = new TreeNode(value);
        if(root==null){
            root=newTreeNode;
        }else{
//            防止左右结点不为空，用死循环
            
            TreeNode currentNode= root;
            TreeNode parentNode;
            for(;;){
//                当左右接点有一个值时，在这个根结点还要追加数据则需要指针不断的移动
                parentNode=currentNode;
                if(currentNode.getvalue()>newTreeNode.getvalue()){
                    currentNode=currentNode.getLeftTreeNode();
                    if(currentNode == null){
                        parentNode.setLeftTreeNode(newTreeNode);
                        return;
                        }
                }else if(currentNode.getvalue()<newTreeNode.getvalue()){
                    currentNode=currentNode.getRightTreeNode();
                    if(currentNode ==null){
                        parentNode.setRightTreeNode(newTreeNode);
                        return;
                    }
                    
                }else{
                    System.out.println("存在相邻的相同的数，该数不能添加");
                    return;//防止死循环
                }
                
                
            }
            
        }
    }
    /**
     * 中序遍历
     */
    public void inOrder(TreeNode treeNode){
        if(treeNode!=null  ){
            inOrder(treeNode.getLeftTreeNode());
            if(treeNode.isDelete()==false){
            System.out.println(treeNode.getvalue());
            }
            inOrder(treeNode.getRightTreeNode());
        }
        
    }

}

public class TestBTree {
    public static void main(String[] args) {
        BinaryTree bTree=new BinaryTree();
        bTree.add(2);
        bTree.add(5);
        bTree.add(9);
        bTree.add(10);
        bTree.add(3);
        bTree.add(90);
        bTree.add(56);
        bTree.add(91);
        TreeNode bTree1 =bTree.getRoot();
        System.out.println("root="+bTree.getRoot().getvalue());
        bTree.inOrder(bTree1);
        System.out.println(bTree1.getvalue());
        TreeNode result=bTree.search(3);
        System.out.println("查找的数据是："+result.getvalue());
//        修改数据1为45
        bTree.replace( 1, 45);
        System.out.println("修改后的数据");
        bTree.inOrder(bTree1);
//        删除2
        bTree.delete(bTree1, 2);
        System.out.println("删除后：");
        bTree.inOrder(bTree1);
    }
}

 

 

 

转载于:https://my.oschina.net/u/3423148/blog/1142669