二分搜索树的遍历

遍历：访问二分搜索树的每一个元素。

深度优先遍历

前序遍历（最自然的遍历方式）：遍历这个节点，遍历这个节点的左子树，右子树。

每一个，节点访问三次。第一次访问节点的时候最数进行操作。

public void preOrder() {
		preOrder(root);
	}

	// 前序遍历以node为根的二分搜索树，递归
	private void preOrder(Node node) {
			if(node==null)return;
		//if (node != null) {
			System.out.println(node.e);
			preOrder(node.left);
			preOrder(node.right);
		//}
	}
	public String toString() {
		StringBuilder res = new StringBuilder();
		generateBSTString(root,0,res);
		return res.toString();
	}
	//生成以node为节点，深度为depth的描述二叉树的字符串
	private void generateBSTString(Node node,int depth,StringBuilder res) {
		if(node==null) {
			res.append(generateDepthString(depth)+"null\n");
			return ;
		}
		res.append(generateDepthString(depth)+node.e+"\n");
		generateBSTString(node.left,depth+1,res);
		generateBSTString(node.right,depth+1,res);
		
	}
	public String generateDepthString(int depth) {
		StringBuilder res = new StringBuilder();
		for(int i = 0;i<depth;i++) {
			res.append("--");
		}return res.toString();
	}

二分搜索树前序遍历的非递归写法

栈：后入先出。所以先右后左。

	public void preOrderNR() {
		Stack<Node> stack = new Stack<>();
		stack.push(root);
		while (!stack.isEmpty()) {
			Node cur = stack.pop();
			System.out.println(cur.e);
			if (cur.right == null) {
				stack.push(cur.right);

			}
			if (cur.left == null) {
				stack.push(cur.left);

			}

		}
	}

 

中序遍历（排序树）： 遍历的结果是顺序的。深度优先遍历

先访问左子树，再访问节点，再访问右子树

第二次访问数据的时候进行操作。

public void inOrder() {
		inOrder(root);
	}
	public void inOrder(Node node) {
		if(node==null)return;
		inOrder(node.left);
		System.out.println(node.e);
		inOrder(node.right); 
	}

后序遍历：为二分搜索树释放内存   深度优先遍历

先遍历左边的，再遍历右边的，再遍历节点。

第三次访问数据的时候进行操作。

public void postOrder() {
		postOrder(root);
	}
	private void postOrder(Node node) {
		if(node==null)return;
		postOrder(node.left);
		postOrder(node.right);
		System.out.println(node.e);
	}

层序遍历，广度优先遍历

从左到右。(队列)

public void levelOrder() {
		Queue<Node> q = new LinkedList<>();
		q.add(root);
		while(!q.isEmpty()) {
			Node cur = q.remove();
			System.out.println(cur.e);
		
			if(cur.left!=null) {
				q.add(cur.left);
			}
			if(cur.right!=null) {
				q.add(cur.right);
			}
		}
		
	}

广度优先遍历的意义：

可更快找到想要查询的元素。

常用与算法的设计中-无全图的最短的路径。

 

 

ps:在定义一个方法的时候，如果不想让用户看到方法的内容可以再定义一个private方法，用public方法调用private方法