超强二叉树解析.必收藏！(数组,链表实现,8种遍历方法,前,中,后序线索化二叉树及其遍历)---风之java
Posted 风生u
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了超强二叉树解析.必收藏！(数组,链表实现,8种遍历方法,前,中,后序线索化二叉树及其遍历)---风之java相关的知识，希望对你有一定的参考价值。
二叉树
链表实现
先创建一个节点类
public class TreeNode {
int value;//数据
TreeNode left;//指向左子树
TreeNode right;//指向右子树
public TreeNode(){}
public TreeNode(int value){
this.value=value;
left=null;
right=null;
}
}
利用数组建立二叉树
利用递归一一将数组中的数全部存储到二叉树中建立二叉树
public TreeNode create(char[] arr,int index){
if(index>=arr.length){
return null;
}else{
TreeNode tmpNode=new TreeNode((int)(arr[index]));
tmpNode.left=create(arr,2*index);
tmpNode.right=create(arr,2*index+1);
return tmpNode;
}
}
整体代码实现
```java
public class BinaryTree {
public TreeNode root;
public TreeNode(){}
public BinaryTree(char[] ch,int index){
root=create(ch,index);
}
//将数组表示法转换为链表表示法
public TreeNode create(char[] arr,int index){
if(index>=arr.length){
return null;
}else{
TreeNode tmpNode=new TreeNode((int)(arr[index]));
tmpNode.left=create(arr,2*index);
tmpNode.right=create(arr,2*index+1);
return tmpNode;
}
}
直接添加元素，建立二叉排序树
public void add(int data){
TreeNode newNode=new TreeNode(data);
//建立树根
if(root==null){
root=newNode;
return;
}
TreeNode cur=root;
while(true){
if(newNode.value<cur.value){
if(cur.left==null){
cur.left=newNode;
return;
}else{
cur=cur.left;
}
}else{
if(cur.right==null){
cur.right=newNode;
return;
}else{
cur=cur.right;
}
}
}
}
二叉树的搜索
可以看到二叉树的搜索是建立在二叉排序树的基础上
//查找该二叉树上是否含有该元素
public boolean findTreeNode(TreeNode root,int value){
if(root==null){
return false;
}else{
if(root.value==value){
return true;
}else{
if(value<root.value){
count++;
return findTreeNode(root.left,value);
}else{
count++;
return findTreeNode(root.right,value);
}
}
}
}
二叉运算树
先创建一个节点类
public class TreeNode {
int value;
TreeNode left;
TreeNode right;
public TreeNode(){}
public TreeNode(int data){
this.value=data;
left=null;
right=null;
}
}
接下来实现二叉运算树
public class BinaryTree {
public TreeNode root;
public BinaryTree(char[] ch,int index){
root=create(ch,index);
}
//添加元素
public void add(int data){
TreeNode newNode=new TreeNode(data);
if(root==null){
root=newNode;
return;
}
TreeNode cur=root;
while(true){
if(newNode.value<cur.value){
if(cur.left==null){
cur.left=newNode;
return;
}else {
cur=cur.left;
}
}else{
if(cur.right==null){
cur.right=newNode;
return;
}else{
cur=cur.right;
}
}
}
}
//将数组表示法转换为链表表示法
public TreeNode create(char[] arr,int index){
if(index>=arr.length){
return null;
}else{
TreeNode tmpNode=new TreeNode((int)(arr[index]));
tmpNode.left=create(arr,2*index);
tmpNode.right=create(arr,2*index+1);
return tmpNode;
}
}
//判断表达式如何运算的方法声明
public int condition(char ch,int n1,int n2){
switch(ch){
case '+': return n1+n2;
case '-': return n1-n2;
case '*': return n1*n2;
case '/': return n1/n2;
case '%': return n1%n2;
default: return -1;
}
}
//计算二叉运算树的值
public int answer(TreeNode root){
int first=0;
int second=0;
if(root.left==null&&root.right==null){
return Character.getNumericValue((char)root.value);
}else{
first=answer(root.left);
second=answer(root.right);
return condition((char)root.value,first,second);
}
}
//中序表示法
public void inOrder(TreeNode root){
if(root!=null){
inOrder(root.left);
System.out.print((char)root.value+" ");
inOrder(root.right);
}
}
//后序表示法
public void postOrder(TreeNode root){
if(root!=null){
postOrder(root.left);
postOrder(root.right);
System.out.print((char)root.value+" ");
}
}
//前序表示法
public void preOrder(TreeNode root){
if(root!=null){
System.out.print((char)root.value+" ");
preOrder(root.left);
preOrder(root.right);
}
}
}
前序遍历递归实现
//前序遍历
public void preOrder1(TreeNode root){
if(root!=null){
System.out.print(root.value+" ");
preOrder1(root.left);//遍历左子树
preOrder1(root.right);//遍历右子树
}
}
前序遍历非递归实现
解法一
利用堆栈的性质
//前序遍历非递归1
public void preOrder2(TreeNode cur){
Stack<TreeNode> stack=new Stack<>();
while(cur!=null||!stack.isEmpty()){
while(cur!=null){
stack.add(cur);
System.out.print(cur.value+" ");
cur=cur.left;
}
cur=stack.pop();
cur=cur.right;
}
}
解法二
将元素按照前序遍历的顺序压入栈中，再依次弹出即可
//前序遍历非递归2
public void preOrder3(TreeNode cur){
Stack<TreeNode> stack=new Stack<>();
stack.add(cur);
while(!stack.isEmpty()){
cur=stack.pop();
System.out.print(cur.value+" ");
if(cur.right!=null)
stack.add(cur.right);
if(cur.left!=null)
stack.add(cur.left);
}
}
中序遍历递归实现
//中序遍历
public void inOrder1(TreeNode root){
if(root!=null){
inOrder1(root.left);//处理左子树
System.out.print(root.value+" ");
inOrder1(root.right);//处理右子树
}
}
中序遍历非递归实现
和前序遍历的非递归实现一样，只不过是交换了打印顺序。
//中序遍历非递归
public void inOrder2(TreeNode cur){
Stack<TreeNode> stack=new Stack<>();
while(cur!=null||!stack.isEmpty()){
while(cur!=null){
stack.add(cur);
cur=cur.left;
}
cur=stack.pop();
System.out.print(cur.value+" ");
cur=cur.right;
}
}
后序遍历递归实现
//后序遍历
public void postOrder1(TreeNode root){
if(root!=null){
postOrder1(root.left);//处理左子树
postOrder1(root.right);//处理右子树
System.out.print(root.value+" ");
}
}
后序遍历非递归实现
后序遍历较为复杂，需要用到栈的性质，且用 cur 来判断打印树叶，用 pre 来记录左或右节点来判断是否打印父节点
public void postOrder2(TreeNode cur){
if(cur==null)
return;
Stack<TreeNode> stack=new Stack<>();
TreeNode pre=null;
stack.add(cur);
while(!stack.isEmpty()){
cur=stack.peek();
if((cur.left==null&&cur.right==null)||(pre!=null&&(pre==cur.left||pre==cur.right))){
System.out.print(cur.value+" ");
stack.pop();
pre=cur;
}else{
if(cur.right!=null)
stack.add(cur.right);
if(cur.left!=null)
stack.add(cur.left);
}
}
}
层序遍历递归实现
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> result = new ArrayList<List<Integer>>();
helper(root, 0, result);
return result;
}
public void helper(TreeNode root, int level, List<List<Integer>> lists) {
if (root == null) {
return;
}
if (lists.size() < level + 1) {
lists.add(new ArrayList<Integer>());
}
lists.get(level).add(root.val);
helper(root.left, level + 1, lists);
helper(root.right, level + 1, lists);以上是关于超强二叉树解析.必收藏！(数组,链表实现,8种遍历方法,前,中,后序线索化二叉树及其遍历)---风之java的主要内容，如果未能解决你的问题，请参考以下文章