遍历一百多万数据进行校验筛选更新某个数据 最高效方案 java 遍历查找

一、前序遍历查找‘

1、判断当前结点的值是否等于需要查找的结点的值，若相等，则直接返回当前结点；
2、若不相等，则判断当前结点的左子结点是否为空，若不为空，则递归前序遍历查找；
3、若左递归前序遍历查找，可以找到结点，则直接返回该结点；
4、否则继续判断，当前的结点的右子结点是否为空，若不空，则继续向右递归前序遍历查找。

public TreeNode preOrderSearch(int val) {
		if(this.val==val) {//若当前结点为需要查找的结点,则直接返回
			return this;
		}
		
		TreeNode temp=null;
		if(this.left!=null) {//若当前结点的左子结点不为空,则向左递归前序查找
			temp=this.left.preOrderSearch(val);
		}
		if(temp!=null) {//若通过左子结点找到则直接返回
			return temp;
		}
		if(this.right!=null) {//以上均未找到,若当前结点的右子结点不为空,则向右递归前序查找
			temp=this.right.preOrderSearch(val);
		}
		return temp;
	}

二、中序遍历查找

1、判断当前结点的左子结点是否为空，若不为空，则递归中序遍历查找；
2、若找到，则直接返回该结点；若没有找到，就和当前结点比较，若相等则返回当前结点；
3、若还是没有找到，判断当前的结点的右子结点是否为空，不为空时继续进行右递归的中序遍历查找。

public TreeNode inOrderSearch(int val) {
		TreeNode temp=null;
		if(this.left!=null) {//若当前结点的左子结点不为空,则向左递归中序查找
			temp=this.left.preOrderSearch(val);
		}
		if(temp!=null) {//若通过左子结点找到则直接返回
			return temp;
		}
		if(this.val==val) {//若当前结点为需要查找的结点,则直接返回
			return this;
		}
		if(this.right!=null) {//以上均未找到,若当前结点的右子结点不为空,则向右递归中序查找
			temp=this.right.preOrderSearch(val);
		}
		return temp;
	}

三、后序遍历查找

1、判断当前结点的左子结点是否为空，若不为空，则递归后序遍历查找
2、若找到，则直接返回该结点；若没有找到，判断当前结点的右子结点是否为空，若不为空，则右递归进行后序遍历查找,若找到,就返回；
3、以上均未找到，则和当前结点进行比较，如果相等则直接返回。

ublic TreeNode postOrderSearch(int val) {
		TreeNode temp=null;
		if(this.left!=null) {//若当前结点的左子结点不为空,则向左递归后序查找
			temp=this.left.preOrderSearch(val);
		}
		if(temp!=null) {//若通过左子结点找到则直接返回
			return temp;
		}
		if(this.right!=null) {//以上均未找到,若当前结点的右子结点不为空,则向右递归后序查找
			temp=this.right.preOrderSearch(val);
		}
		if(this.val==val) {//若当前结点为需要查找的结点,则直接返回
			return this;
		}
		return temp;
	}

四、代码完整实现

package Tree;

public class BinaryTreeSearch {
	public static void main(String[] args) {
		TreeNode root=new TreeNode(7,'A');//创建二叉树
		TreeNode a=new TreeNode(4,'B');
		TreeNode b=new TreeNode(9,'C');
		TreeNode c=new TreeNode(2,'D');
		TreeNode d=new TreeNode(5,'E');
		TreeNode e=new TreeNode(8,'F');
		TreeNode f=new TreeNode(11,'G');
		TreeNode g=new TreeNode(1,'H');
		TreeNode h=new TreeNode(3,'I');
		TreeNode i=new TreeNode(10,'J');
		TreeNode j=new TreeNode(12,'K');
		root.left=a;
		root.right=b;
		a.left=c;
		a.right=d;
		b.left=e;
		b.right=f;
		c.left=g;
		c.right=h;
		f.left=i;
		f.right=j;
		
		//前序遍历查找
		System.out.println("前序遍历查找");
		TreeNode temp1=root.preOrderSearch(9);
		if (temp1!= null) {
			System.out.printf(temp1.toString());
		} else {
			System.out.printf("没有找到该结点\n");
		}
		System.out.println();
		//中序遍历查找
		System.out.println("中序遍历查找");
		TreeNode temp2=root.preOrderSearch(11);
		if (temp2!= null) {
			System.out.printf(temp2.toString());
		} else {
			System.out.printf("没有找到该结点\n");
		}
		System.out.println();
		//后序遍历查找
		System.out.println("后序遍历查找");
		TreeNode temp3=root.preOrderSearch(1);
		if (temp3!= null) {
			System.out.printf(temp3.toString());
		} else {
			System.out.printf("没有找到该结点\n");
		}
		System.out.println();
	}
}

class TreeNode{
	int val;
	char ch;
	TreeNode left;//默认null
    TreeNode right;//默认null

    public TreeNode(int val,char ch) {
        this.val = val;
        this.ch=ch;
    }
    //重写toString方法
    @Override
	public String toString() {
		return "TreeNode [val=" + val + ", ch=" + ch + "]";
	}
	
	//前序遍历查找(根->左->右)
	public TreeNode preOrderSearch(int val) {
		if(this.val==val) {//若当前结点为需要查找的结点,则直接返回
			return this;
		}
		
		TreeNode temp=null;
		if(this.left!=null) {//若当前结点的左子结点不为空,则向左递归前序查找
			temp=this.left.preOrderSearch(val);
		}
		if(temp!=null) {//若通过左子结点找到则直接返回
			return temp;
		}
		if(this.right!=null) {//以上均未找到,若当前结点的右子结点不为空,则向右递归前序查找
			temp=this.right.preOrderSearch(val);
		}
		return temp;
	}
	
	
	// 中序遍历查找(左->根->右)
	public TreeNode inOrderSearch(int val) {
		TreeNode temp=null;
		if(this.left!=null) {//若当前结点的左子结点不为空,则向左递归中序查找
			temp=this.left.preOrderSearch(val);
		}
		if(temp!=null) {//若通过左子结点找到则直接返回
			return temp;
		}
		if(this.val==val) {//若当前结点为需要查找的结点,则直接返回
			return this;
		}
		if(this.right!=null) {//以上均未找到,若当前结点的右子结点不为空,则向右递归中序查找
			temp=this.right.preOrderSearch(val);
		}
		return temp;
	}
	
	// 后序遍历查找(左->右->根)
	public TreeNode postOrderSearch(int val) {
		TreeNode temp=null;
		if(this.left!=null) {//若当前结点的左子结点不为空,则向左递归后序查找
			temp=this.left.preOrderSearch(val);
		}
		if(temp!=null) {//若通过左子结点找到则直接返回
			return temp;
		}
		if(this.right!=null) {//以上均未找到,若当前结点的右子结点不为空,则向右递归后序查找
			temp=this.right.preOrderSearch(val);
		}
		if(this.val==val) {//若当前结点为需要查找的结点,则直接返回
			return this;
		}
		return temp;
	}
}

运行结果：

前序遍历查找
TreeNode [val=9, ch=C]
中序遍历查找
TreeNode [val=11, ch=G]
后序遍历查找
TreeNode [val=1, ch=H]

该实例的二叉树图如下图所示：