哈希，二叉树，集合排序

哈希：

哈希是密码学的基础
哈希函数的运算结果简称哈希值
哈希函数也称散列函数
根据维基百科的定义，哈希函数是将任意大小的数据，生成出一个固定长度的数据来作为它的映射，它是一种单向密码体制，即一个从明文到密文的不可逆映射，只有加密过程，没有解密过程。

二叉树：

package com.cn.二叉树;

public class TestRoot {

	    private TreeNode treeRoot;

	    public TreeNode getTreeRoot() {
	        return treeRoot;
	    }

	    public void setTreeRoot(TreeNode treeRoot) {
	        this.treeRoot = treeRoot;
	    }
	    
	    /**
	     * 先序遍历
	     * @param rootTreeNode  根节点
	     */
	    public static void preTraverseBTree(TreeNode rootTreeNode) {

	        if (rootTreeNode != null) {

	            //访问根节点
	            System.out.println(rootTreeNode.getValue());

	            //访问左节点
	            preTraverseBTree(rootTreeNode.getLefTreeNode());

	            //访问右节点
	            preTraverseBTree(rootTreeNode.getRightNode());
	        }
	    }
	    /**
	     * 中序遍历
	     * @param rootTreeNode  根节点
	     */
	    public static void inTraverseBTree(TreeNode rootTreeNode) {

	        if (rootTreeNode != null) {

	            //访问左节点
	            inTraverseBTree(rootTreeNode.getLefTreeNode());

	            //访问根节点
	            System.out.println(rootTreeNode.getValue());

	            //访问右节点
	            inTraverseBTree(rootTreeNode.getRightNode());
	        }
	    }
	    /**
	     * 动态创建二叉查找树
	     *
	     * @param treeRoot 根节点
	     * @param value    节点的值
	     */
	    public static void createTree(TestRoot treeRoot, int value) {


	        //如果树根为空(第一次访问)，将第一个值作为根节点
	        if (treeRoot.getTreeRoot() == null) {
	            TreeNode treeNode = new TreeNode(value);
	            treeRoot.setTreeRoot(treeNode);

	        } else  {

	            //当前树根
	            TreeNode tempRoot = treeRoot.getTreeRoot();

	            while (tempRoot != null) {
	                //当前值大于根值，往右边走
	                if (value > tempRoot.getValue()) {

	                    //右边没有树根，那就直接插入
	                    if (tempRoot.getRightNode() == null) {
	                        tempRoot.setRightNode(new TreeNode(value));
	                        return ;
	                    } else {
	                        //如果右边有树根，到右边的树根去
	                        tempRoot = tempRoot.getRightNode();
	                    }
	                } else {
	                    //左没有树根，那就直接插入
	                    if (tempRoot.getLefTreeNode() == null) {
	                        tempRoot.setLefTreeNode(new TreeNode(value));

	                        return;
	                    } else {
	                        //如果左有树根，到左边的树根去
	                        tempRoot = tempRoot.getLefTreeNode();
	                    }
	                }
	            }
	        }
	    }
	}

package com.cn.二叉树;

public class TreeNode {

    // 左节点(儿子)
    private TreeNode lefTreeNode;
    
    // 右节点(儿子)
    private TreeNode rightNode;
    
    // 数据
    private int value;
    
    public TreeNode(int value) {
    	this.value=value;
    }

	public TreeNode getLefTreeNode() {
		return lefTreeNode;
	}

	public void setLefTreeNode(TreeNode lefTreeNode) {
		this.lefTreeNode = lefTreeNode;
	}

	public TreeNode getRightNode() {
		return rightNode;
	}

	public void setRightNode(TreeNode rightNode) {
		this.rightNode = rightNode;
	}

	public int getValue() {
		return value;
	}

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

集合排序：

用这个工具类Collections.sort(list)（当然你可以用Arrays排序数组，我说的集合）

其中的list需要是实现了Comparable

重写方法：

@overrite

public int compareTo(T o){
if(o == null){
return -1;
}
if (this == o)
return 0;
return this.name.compareTo(o.name);
}