数据结构——二叉树的遍历

已于 2022-02-27 12:53:09 修改
阅读量601 收藏 1
点赞数
分类专栏： # 数据结构与算法 文章标签： 数据结构
于 2022-02-27 12:52:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shintyan/article/details/123162210
版权

一、二叉树的前序、中序、后序遍历的递归、非递归、迭代器版本

(1)Tree.java

package com.zx.tree;

import java.util.Stack;

public class Tree {
	
	private Node root;
	private Integer[] ans;
	private Integer size;
	private Integer cnt;
	
	public Tree(){
		root = null;
		ans = null;
		size = null;
		cnt = null;
	}
	
	public Tree(Integer[] ans){
		this.ans=ans;
		size=this.ans.length;
		cnt = null;
		root = build(0);
	}
	
	private Node build(Integer pos){
		Node node = new Node();
		node.setData(ans[pos]);
		if(pos*2+1<size) node.setLnode(build(pos*2+1));
		if(pos*2+2<size) node.setRnode(build(pos*2+2));
		return node;
	}
	
	private void reset(){
		if(size == null) return ;
		
		ans = new Integer[size];		
		for(int i=0;i<size;i++)
			ans[i]=0;
		
		cnt = 0;
	}
	
	private void visit(Node node){
		ans[cnt++] = node.getData();
	}
	
	//----------------------------------------------------------------------
	//递归形式前序遍历
	public Integer[] preList() {
		reset();
		dfsPre(root);
		return ans;
	}
	
	//递归形式前序遍历
	private void dfsPre(Node node){
		if(node == null) return ;
		visit(node);
		dfsPre(node.getLnode());
		dfsPre(node.getRnode());
	}
	
	//----------------------------------------------------------------------
	//递归形式中序遍历
	public Integer[] midList() {
		reset();
		dfsMid(root);
		return ans;
		
	}
	
	//递归形式中序遍历
	private void dfsMid(Node node){
		if(node == null) return ;
		dfsMid(node.getLnode());
		visit(node);
		dfsMid(node.getRnode());
	}
	
	
	//----------------------------------------------------------------------
	//递归形式后续遍历
	public Integer[] lastList() {
		reset();
		dfsLast(root);
		return ans;
		
	}
	
	//递归形式后续遍历
	private void dfsLast(Node node){
		if(node == null) return ;
		dfsLast(node.getLnode());
		dfsLast(node.getRnode());
		visit(node);
	}
	
	
	
	//----------------------------------------------------------------------
	//非递归形式前序遍历
	public Integer[] stackPreList() {
		reset();
		Stack<Node> stack = new Stack<>();
		
		Node p = root;
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				visit(p);
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				p = stack.pop();
				p = p.getRnode();
			}
		}
		return ans;
	}
	
	
	//----------------------------------------------------------------------
	//非递归形式中续遍历
	public Integer[] stackMidList() {
		reset();
		Stack<Node> stack = new Stack<>();
		
		Node p = root;
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				p = stack.pop();
				visit(p);
				p = p.getRnode();
			}
		}
		return ans;
	}
	
	
	//----------------------------------------------------------------------
	//非递归形式后续遍历
	public Integer[] stackLastList() {
		reset();
		Stack<Node> stack = new Stack<>();
		
		Node p = root;
		//后续遍历为左右根
		//r表示上一个访问的节点，用来判断是不是从右子树返回的
		Node r = null;
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				//查看栈顶
				p = stack.peek();
				
				if(p.getRnode() != null && p.getRnode() != r)//右子树存在且未被访问过
				{
					p = p.getRnode();
					stack.add(p);
					p = p.getLnode();
				}
				else
				{
					p = stack.pop();
					visit(p);
					r = p;
					//访问完以p为根的子树
					p = null;
				}
			}
		}
		return ans;
	}
	
	
	
	
	//利用迭代器实现遍历
	//采用非递归形式
	public Iter getPreIter() {
		return new PreIter(root);
	}
	
	public Iter getMidIter() {
		return new MidIter(root);
	}
	
	public Iter getLastIter() {
		return new LastIter(root);
	}
	
}


class Node
{
	private Integer data;
	private Node lnode;
	private Node rnode;
	
	public Node() {
		data = null;
		lnode = null;
		rnode = null;
	}
	
	public Integer getData() {
		return data;
	}
	public void setData(Integer data) {
		this.data = data;
	}
	public Node getLnode() {
		return lnode;
	}
	public void setLnode(Node lnode) {
		this.lnode = lnode;
	}
	public Node getRnode() {
		return rnode;
	}
	public void setRnode(Node rnode) {
		this.rnode = rnode;
	}
	
}

(2) Iter.java

package com.zx.tree;

public interface Iter {
	public abstract boolean hasNext() ;
	public abstract Integer next();
}

(3)PreIter.java

package com.zx.tree;

import java.util.Stack;

public class PreIter implements Iter{
	private Node root;
	Stack<Node> stack;
	private Node p;
	
	public PreIter(Node root)
	{
		this.root = root;
		stack = new Stack<>();
		this.p = this.root;
	}
	
	@Override
	public boolean hasNext() {
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				return true;
			}
			else
			{
				p = stack.pop();
				p = p.getRnode();
			}
		}
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public Integer next() {
		
		stack.add(p);
		Integer ans = p.getData();
		p = p.getLnode();
		return ans ;
		// TODO Auto-generated method stub
	}
	
	
	
}

(4)MidIter.java

package com.zx.tree;

import java.util.Stack;

public class MidIter  implements Iter{
	private Node root;
	Stack<Node> stack;
	private Node p;
	
	public MidIter(Node root)
	{
		this.root = root;
		stack = new Stack<>();
		this.p = this.root;
	}
	
	@Override
	public boolean hasNext() {
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				return true;
			}
		}
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public Integer next() {
		
		p = stack.pop();
		Integer ans = p.getData();
		p = p.getRnode();
		return ans ;
		// TODO Auto-generated method stub
	}
	
	
	
}

(5)LastIter.java

package com.zx.tree;

import java.util.Stack;

public class LastIter implements Iter{
	private Node root;
	Stack<Node> stack;
	private Node p;
	private Node r;
	
	public LastIter(Node root)
	{
		this.root = root;
		stack = new Stack<>();
		this.p = this.root;
		this.r = null;
	}
	
	@Override
	public boolean hasNext() {
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				p = stack.peek();
				if(p.getRnode()!=null && p.getRnode() !=r)
				{
					p = p.getRnode();
					stack.add(p);
					p = p.getLnode();
				}
				else
				{
					return true;
				}
			}
		}
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public Integer next() {
		
		p = stack.pop();
		Integer ans = p.getData();
		r = p;
		p = null;
		return ans ;
		// TODO Auto-generated method stub
	}
	
	
	
}

(6)main.java

package com.zx.tree;

public class Main {
	
	public static Integer[] ans = {1,2,3,4,5,6,7,8,9,10,11,12};
	
	private static void printArray(Integer[] ans)
	{
		for(int i=0;i<ans.length;i++)
			System.out.print(ans[i]+" ");
		System.out.println("");
	}
	
	private static void printIter(Iter iter)
	{
		while(iter.hasNext())
			System.out.print(iter.next()+" ");
		System.out.println("");
	}
	
	public static void main(String[] args) {
		Tree t = new Tree(ans);
		System.out.println("前序遍历");
		System.out.print("递归:  ");
		printArray(t.preList());
		
		System.out.print("非递归:");
		printArray(t.stackPreList());
		
		System.out.print("迭代:  ");
		printIter(t.getPreIter());
		
		System.out.println("--------------------------------------------------");
		
		System.out.println("中序遍历");
		System.out.print("递归:  ");
		printArray(t.midList());
		
		System.out.print("非递归:");
		printArray(t.stackMidList());
		
		System.out.print("迭代:  ");
		printIter(t.getMidIter());

		System.out.println("--------------------------------------------------");
		
		System.out.println("后序遍历");
		System.out.print("递归:  ");
		printArray(t.lastList());
		
		System.out.print("非递归:");
		printArray(t.stackLastList());
		
		System.out.print("迭代:  ");
		printIter(t.getLastIter());

		System.out.println("--------------------------------------------------");
		
	}

}

输出：

前序遍历
递归:  1 2 4 8 9 5 10 11 3 6 12 7 
非递归:1 2 4 8 9 5 10 11 3 6 12 7 
迭代:  1 2 4 8 9 5 10 11 3 6 12 7 
--------------------------------------------------
中序遍历
递归:  8 4 9 2 10 5 11 1 12 6 3 7 
非递归:8 4 9 2 10 5 11 1 12 6 3 7 
迭代:  8 4 9 2 10 5 11 1 12 6 3 7 
--------------------------------------------------
后序遍历
递归:  8 9 4 10 11 5 2 12 6 7 3 1 
非递归:8 9 4 10 11 5 2 12 6 7 3 1 
迭代:  8 9 4 10 11 5 2 12 6 7 3 1 
--------------------------------------------------

二、泛型版本

（1）Tree.java

package com.zx.treet;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class Tree <T>{
	
	private Node<T> root;
	private List<T> ans;
	private Integer size;
	
	public Tree(){
		root = null;
		ans = null;
		size = null;
	}
	
	public Tree(List<T> ans){
		this.ans=ans;
		size=this.ans.size();
		root = build(0);
	}
	
	private Node<T> build(Integer pos){
		Node<T> node = new Node<>();
		node.setData(ans.get(pos));
		if(pos*2+1<size) node.setLnode(build(pos*2+1));
		if(pos*2+2<size) node.setRnode(build(pos*2+2));
		return node;
	}
	
	private void reset(){
		if(size == null) return ;
		
		ans = new ArrayList<>();		

	}
	
	private void visit(Node<T> node){
		ans.add(node.getData());
	}
	
	//----------------------------------------------------------------------
	//递归形式前序遍历
	public List<T> preList() {
		reset();
		dfsPre(root);
		return ans;
	}
	
	//递归形式前序遍历
	private void dfsPre(Node<T> node){
		if(node == null) return ;
		visit(node);
		dfsPre(node.getLnode());
		dfsPre(node.getRnode());
	}
	
	//----------------------------------------------------------------------
	//递归形式中序遍历
	public List<T> midList() {
		reset();
		dfsMid(root);
		return ans;
		
	}
	
	//递归形式中序遍历
	private void dfsMid(Node<T> node){
		if(node == null) return ;
		dfsMid(node.getLnode());
		visit(node);
		dfsMid(node.getRnode());
	}
	
	
	//----------------------------------------------------------------------
	//递归形式后续遍历
	public List<T> lastList() {
		reset();
		dfsLast(root);
		return ans;
		
	}
	
	//递归形式后续遍历
	private void dfsLast(Node<T> node){
		if(node == null) return ;
		dfsLast(node.getLnode());
		dfsLast(node.getRnode());
		visit(node);
	}
	
	
	
	//----------------------------------------------------------------------
	//非递归形式前序遍历
	public List<T> stackPreList() {
		reset();
		Stack<Node<T>> stack = new Stack<>();
		
		Node<T> p = root;
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				visit(p);
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				p = stack.pop();
				p = p.getRnode();
			}
		}
		return ans;
	}
	
	
	//----------------------------------------------------------------------
	//非递归形式中续遍历
	public List<T> stackMidList() {
		reset();
		Stack<Node<T>> stack = new Stack<>();
		
		Node<T> p = root;
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				p = stack.pop();
				visit(p);
				p = p.getRnode();
			}
		}
		return ans;
	}
	
	
	//----------------------------------------------------------------------
	//非递归形式后续遍历
	public List<T> stackLastList() {
		reset();
		Stack<Node<T>> stack = new Stack<>();
		
		Node<T> p = root;
		//后续遍历为左右根
		//r表示上一个访问的节点，用来判断是不是从右子树返回的
		Node<T> r = null;
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				//查看栈顶
				p = stack.peek();
				
				if(p.getRnode() != null && p.getRnode() != r)//右子树存在且未被访问过
				{
					p = p.getRnode();
					stack.add(p);
					p = p.getLnode();
				}
				else
				{
					p = stack.pop();
					visit(p);
					r = p;
					//访问完以p为根的子树
					p = null;
				}
			}
		}
		return ans;
	}
	
	
	
	
	//利用迭代器实现遍历
	//采用非递归形式
	public Iter<T> getPreIter() {
		return new PreIter<T>(root);
	}
	
	public Iter<T> getMidIter() {
		return new MidIter<T>(root);
	}
	
	public Iter<T> getLastIter() {
		return new LastIter<T>(root);
	}
	
}


class Node <T>
{
	private T data;
	private Node<T> lnode;
	private Node<T> rnode;
	
	public Node() {
		data = null;
		lnode = null;
		rnode = null;
	}
	
	public T getData() {
		return data;
	}
	public void setData(T data) {
		this.data = data;
	}
	public Node<T> getLnode() {
		return lnode;
	}
	public void setLnode(Node<T> lnode) {
		this.lnode = lnode;
	}
	public Node<T> getRnode() {
		return rnode;
	}
	public void setRnode(Node<T> rnode) {
		this.rnode = rnode;
	}
	
}

(2)Iter.java

package com.zx.treet;

public interface Iter<T> {
	public abstract boolean hasNext() ;
	public abstract T next();
}

(3)PreIter.java

package com.zx.treet;

import java.util.Stack;

public class PreIter<T> implements Iter <T>{
	private Node<T> root;
	Stack<Node<T>> stack;
	private Node<T> p;
	
	public PreIter(Node<T> root)
	{
		this.root = root;
		stack = new Stack<>();
		this.p = this.root;
	}
	
	@Override
	public boolean hasNext() {
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				return true;
			}
			else
			{
				p = stack.pop();
				p = p.getRnode();
			}
		}
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public T next() {
		
		stack.add(p);
		T ans = p.getData();
		p = p.getLnode();
		return ans ;
		// TODO Auto-generated method stub
	}
	
	
	
}

(4)MidIter.java

package com.zx.treet;

import java.util.Stack;

public class MidIter<T>  implements Iter<T>{
	private Node<T> root;
	Stack<Node<T>> stack;
	private Node<T> p;
	
	public MidIter(Node<T> root)
	{
		this.root = root;
		stack = new Stack<>();
		this.p = this.root;
	}
	
	@Override
	public boolean hasNext() {
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				return true;
			}
		}
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public T next() {
		
		p = stack.pop();
		T ans = p.getData();
		p = p.getRnode();
		return ans ;
		// TODO Auto-generated method stub
	}
	
	
	
}

(5)LastIter.java

package com.zx.treet;

import java.util.Stack;

public class LastIter<T> implements Iter<T>{
	private Node<T> root;
	Stack<Node<T>> stack;
	private Node<T> p;
	private Node<T> r;
	
	public LastIter(Node<T> root)
	{
		this.root = root;
		stack = new Stack<>();
		this.p = this.root;
		this.r = null;
	}
	
	@Override
	public boolean hasNext() {
		
		while(p != null || !stack.empty())
		{
			if(p!=null)
			{
				stack.add(p);
				p = p.getLnode();
			}
			else
			{
				p = stack.peek();
				if(p.getRnode()!=null && p.getRnode() !=r)
				{
					p = p.getRnode();
					stack.add(p);
					p = p.getLnode();
				}
				else
				{
					return true;
				}
			}
		}
		// TODO Auto-generated method stub
		return false;
	}
	@Override
	public T next() {
		
		p = stack.pop();
		T ans = p.getData();
		r = p;
		p = null;
		return ans ;
		// TODO Auto-generated method stub
	}
	
	
	
}

(6)Main.java

package com.zx.treet;

import java.util.ArrayList;
import java.util.List;

public class Main {
	
	public static List<Integer> ans ;
	public static List<String> res;
	
	public static void init() {
		ans = new ArrayList<>();
		for(int i=1;i<=12;i++)
			ans.add(i);
		
		res = new ArrayList<>();
		for(int i=0;i<12;i++)
			res.add((char)('a'+i)+"");
	}
	
	

	public static void main(String[] args) {
		
		init();
		
		startInteger();
		startString();
		
		
	}
	
	public static void startInteger() {
		Tree<Integer> t = new Tree<>(ans);
		
		System.out.println("前序遍历");
		System.out.print("递归:  ");
		List<Integer> res = t.preList();
		for(Integer x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		System.out.print("非递归:");
		res = t.stackPreList();
		for(Integer x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		
		System.out.print("迭代:  ");
		Iter<Integer> iter = t.getPreIter();
		while(iter.hasNext())
			System.out.print(iter.next()+" ");
		System.out.println("");
		
		System.out.println("--------------------------------------------------");
		
		System.out.println("中序遍历");
		System.out.print("递归:  ");
		res = t.midList();
		for(Integer x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		System.out.print("非递归:");
		res = t.stackMidList();
		for(Integer x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		
		System.out.print("迭代:  ");
		iter = t.getMidIter();
		while(iter.hasNext())
			System.out.print(iter.next()+" ");
		System.out.println("");

		System.out.println("--------------------------------------------------");
		
		System.out.println("后序遍历");
		System.out.print("递归:  ");
		res = t.lastList();
		for(Integer x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		System.out.print("非递归:");
		res = t.stackLastList();
		for(Integer x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		
		System.out.print("迭代:  ");
		iter = t.getLastIter();
		while(iter.hasNext())
			System.out.print(iter.next()+" ");
		System.out.println("");

		System.out.println("--------------------------------------------------");
		System.out.println("--------------------------------------------------");
		System.out.println("--------------------------------------------------");
	}
	
	public static void startString() {
		Tree<String> t = new Tree<>(res);
		
		System.out.println("前序遍历");
		System.out.print("递归:  ");
		List<String> res = t.preList();
		for(String x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		System.out.print("非递归:");
		res = t.stackPreList();
		for(String x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		
		System.out.print("迭代:  ");
		Iter<String> iter = t.getPreIter();
		while(iter.hasNext())
			System.out.print(iter.next()+" ");
		System.out.println("");
		
		System.out.println("--------------------------------------------------");
		
		System.out.println("中序遍历");
		System.out.print("递归:  ");
		res = t.midList();
		for(String x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		System.out.print("非递归:");
		res = t.stackMidList();
		for(String x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		
		System.out.print("迭代:  ");
		iter = t.getMidIter();
		while(iter.hasNext())
			System.out.print(iter.next()+" ");
		System.out.println("");

		System.out.println("--------------------------------------------------");
		
		System.out.println("后序遍历");
		System.out.print("递归:  ");
		res = t.lastList();
		for(String x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		System.out.print("非递归:");
		res = t.stackLastList();
		for(String x : res)
			System.out.print(x+" ");
		System.out.println("");
		
		
		System.out.print("迭代:  ");
		iter = t.getLastIter();
		while(iter.hasNext())
			System.out.print(iter.next()+" ");
		System.out.println("");

		System.out.println("--------------------------------------------------");
		System.out.println("--------------------------------------------------");
		System.out.println("--------------------------------------------------");
	}


}

输出：

前序遍历
递归:  1 2 4 8 9 5 10 11 3 6 12 7 
非递归:1 2 4 8 9 5 10 11 3 6 12 7 
迭代:  1 2 4 8 9 5 10 11 3 6 12 7 
--------------------------------------------------
中序遍历
递归:  8 4 9 2 10 5 11 1 12 6 3 7 
非递归:8 4 9 2 10 5 11 1 12 6 3 7 
迭代:  8 4 9 2 10 5 11 1 12 6 3 7 
--------------------------------------------------
后序遍历
递归:  8 9 4 10 11 5 2 12 6 7 3 1 
非递归:8 9 4 10 11 5 2 12 6 7 3 1 
迭代:  8 9 4 10 11 5 2 12 6 7 3 1 
--------------------------------------------------
--------------------------------------------------
--------------------------------------------------
前序遍历
递归:  a b d h i e j k c f l g 
非递归:a b d h i e j k c f l g 
迭代:  a b d h i e j k c f l g 
--------------------------------------------------
中序遍历
递归:  h d i b j e k a l f c g 
非递归:h d i b j e k a l f c g 
迭代:  h d i b j e k a l f c g 
--------------------------------------------------
后序遍历
递归:  h i d j k e b l f g c a 
非递归:h i d j k e b l f g c a 
迭代:  h i d j k e b l f g c a 
--------------------------------------------------
--------------------------------------------------
--------------------------------------------------

shintyan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——二叉树的生成与遍历
02-18
数据结构，实现二叉树的生成与遍历的算法。包含利用先序、中序、后序遍历二叉树算法，二叉树基本操作。（注意没有左子树或右子树时用@或#作为结束符号）
【数据结构】二叉树的遍历
专注于Java领域开发 关注我 带你玩转Java
09-12 846
二叉树的遍历
数据结构--二叉树遍历
最新发布
binhyun的博客
07-15 712
（1）前序遍历 （2）定义结构体 （3）前序遍历实现 （4）中序遍历实现 （5）二叉树的节点个数 （6）二叉树树叶节点个数 （7）二叉树的高度 （8）二叉树节点的开辟 （9）建立一个测试二叉树 （10）测试二叉树相关函数的功能 （11）第k层的数据个数 （12）二叉树里面查找节点
数据结构之二叉树的遍历
weixin_30394981的博客
03-06 100
二叉树的遍历分为前序遍历，中序遍历，后序遍历，层序遍历，在本文中，前三种由递归实现，层序遍历由队列实现。 #include "stdio.h" #include "stdlib.h" #include "windows.h" typedef struct Node { char data; struct Node *Left; struct Nod...
二叉树的遍历 - 数据结构和算法46
weixin_34408717的博客
04-04 69
二叉树的遍历 让编程改变世界 Change the world by program 二叉树的遍历(traversing binary tree)是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次。 这里有两个关键词小甲鱼给加红了：次序和访问 二叉树的遍历次序不同于线性结构，线性结构最多也就是分为顺序、循环、双向等简单的遍历方式...
数据结构-二叉树遍历
若疆~赤云
03-14 248
采用顺序结构来保存二叉树，程序遍历底层数组即可。 采用链表保存二叉树： 1、深度优先遍历：先访问到树中最深层次的节点     L：左子树    D：根    R：右子树     1）先（前）序遍历二叉树    DLR     2）中序遍历二叉树              LDR     3）后序遍历二叉树              LRD 2、广度优先遍历：逐层访问每层的节点，也叫按...
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
数据结构——二叉树 线索化二叉树 C语言
03-16
中序线索二叉树，反方向进行中序遍历(要求非递归，顺前驱进行)。 （1）建立二叉树； (2) 按先序、中序、后序输出二叉树; （3）复制二叉树； （4）在字符模式下画出无缺陷的二叉树
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
数据结构实验——二叉树相关操作
05-13
本人本科期间数据结构二叉树的实验 1、建立二叉树的存储结构 2、先序、中序、后序遍历二叉树（要求任选某一种用非递归算法完成） 3、查询二叉树中某个结点 4、统计二叉树中叶子结点的个数 5、求二叉树的深度 6、要求...
课程设计报告数据结构二叉树遍历演示_二叉树中序遍历怎么看
01-08
**课程设计报告——数据结构中的二叉树遍历演示** 在数据结构课程设计中，二叉树遍历是一项重要的实践任务。二叉树遍历主要包括前序遍历、中序遍历和后序遍历，这三种遍历方法在理解和应用二叉树时具有基础性的地位...
【数据结构】二叉树遍历-整体思维版本 .zip
10-01
在计算机科学领域，数据结构是基础且至关重要的概念，它为高效地组织和处理数据提供了方法。二叉树作为数据结构的一种，具有独特的性质和应用，尤其在算法设计中扮演着重要角色。在这个主题中，我们将深入探讨二叉树...
数据结构——基于C语言实现二叉树的应用.cpp
08-11
/创建二叉树 //初始化二叉树 //创建队列 //出队 //队列判空 //入队 //先序递归遍历 //后序递归遍历 //中序递归遍历 //层次遍历
数据结构——二叉树有关操作程序
12-17
(1)以二叉链表作为存储结构，从键盘以先序次序输入各个结点（空格字符表示空树）建立一棵二叉树； (2)对（1）中生成的二叉树进行判空； (3)对（1）中生成的二叉树进行遍历（分别实现先序遍历、中序遍历、后序...
数据结构-二叉树的遍历
huang
03-16 452
6-4二叉树的遍历（20分) 时间限制: 400 ms 内存限制: 64 MB 代码长度限制: 16 KB 本题要求给定二叉树的4种遍历。 函数接口定义： void InorderTraversal( BinTree BT ); void PreorderTraversal( BinTree BT ); void Postord...
数据结构 - 二叉树的遍历
yffhhffv的博客
11-02 493
分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 二叉树的遍历N：访问根
数据结构：二叉树的遍历和存储结构
Meditation
04-28 3992
在《二叉树的定义和性质》中我们已经认识了二叉树这种数据结构。我们知道链表的每个节点可以有一个后继，而二叉树（Binary Tree）的每个节点可以有两个后继。比如这样定义二叉树的节点： typedef struct node *link; struct node {  unsigned char item;  link l, r; }; 这样的节点可以组织成下图所示的形态。
C++数据结构——中序遍历二叉树
05-23
中序遍历是二叉树遍历的一种，遍历顺序为左子树、根节点、右子树。以下是C++代码实现： ```c++ #include using namespace std; struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode(int x...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值