1.树的概念
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
1.1树的性质
节点的度：一个节点含有子树的个数称为该节点的度。(如节点A的度为3)。
树的度：一棵树中最大节点的度称为该树的度。(如上图中树的度就是3)。
叶子节点或终端节点：度为0的节点称为叶子节点或终端节点。(上图中的D，E，F，G，H都是叶子节点或者终端节点。)
双亲节点或父节点：若一个节点含有子节点，就称这个节点为其子节点的父节点或双亲节点。(如A是B的父节点。）
根结点：一棵树中没有双亲节点的节点称为根节点(如上图中的A)
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推。
树的高度或深度：树中节点的最大层次； 如上图：树的高度为3。
非终端节点或分支节点：度不为0的节点； 如上图：A，B，C等节点为分支节点
兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C，D是兄弟节点
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：F，G互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>=0）棵互不相交的树的集合称为森林。
1.2树的表示
class Node{
int value; //树存储的数据
Node child; //第一个孩子的引用
Node brother; //兄弟节点
}
2.二叉树
2.1概念
一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
特点：
1. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
2. 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。
2.2两种特殊的二叉树
1. 满二叉树: 一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是
2
k
−
1
2^k-1
2k−1 ，则它就是满二叉树。
2. 完全二叉树: 完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
满二叉树图：
完全二叉树图：
2.3二叉树的性质
- 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2 i − 1 2^{i-1} 2i−1(i>0)个结点。
- 若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的最大结点数是 2 k − 1 2^k-1 2k−1(k>=0)。
- 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0＝n2＋1。
- 具有n个结点的完全二叉树的深度k为 l o g 2 ( n + 1 ) log_2(n+1) log2(n+1)上取整。
- 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有：
。若i>0，双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点。
。若2i+1<n，左孩子序号：2i+1，否则无左孩子。
。若2i+2<n，右孩子序号：2i+2，否则无右孩子。
2.4二叉树的存储
class Node{
int value; //树存储的数据
Node left; //左孩子引用，通常代表左孩子为根的整棵树
Node right; //右孩子引用，通常代表右孩子为根的整棵树
}
2.5二叉树的基本操作
2.5.1构建一颗二叉树
class Node{
int var;
Node left;
Node right;
public Node(int var) {
this.var = var;
}
public static Node createBinaryTree(){
Node a=new Node(1);
Node b=new Node(2);
Node c=new Node(3);
Node d=new Node(4);
Node e=new Node(5);
Node f=new Node(6);
a.left=b;
a.right=c;
b.left=d;
b.right=e;
c.left=f;
return a;
}
}
2.5.2二叉树的遍历等操作
class Node{
int var;
Node left;
Node right;
public Node(int var) {
this.var = var;
}
@Override
public String toString() {
return "Node{" +
"var=" + var +
'}';
}
public static Node createBinaryTree(){
Node a=new Node(1);
Node b=new Node(2);
Node c=new Node(3);
Node d=new Node(4);
Node e=new Node(5);
Node f=new Node(6);
a.left=b;
a.right=c;
b.left=d;
b.right=e;
c.left=f;
return a;
}
}
public class TestTree {
public static void main(String[] args) {
Node root=Node.createBinaryTree();
//先序遍历
// preOrderTraversal(root);
//中序遍历
// inOrderTraversal(root);
//后序遍历
// postOrderTraversal(root);
//求二叉树的节点个数
getsize(root);
System.out.println("++++++++++++");
System.out.println(count);
//求叶子节点的个数
getLeafSize(root);
System.out.println(leafSize);
//求第K层节点的个数
int result=getKLeafSize(root,2);
System.out.println(result);
//求二叉树的高度
int result1= getheight(root);
System.out.println(result1);
//查找某个节点
Node curNode= find(root,3);
System.out.println(curNode);
}
public static Node find(Node root, int i) {
if(root==null){
return null;
}
if(root.var==i){
return root;
}
//递归的去左边找
Node result=find(root.left,i);
if(result!=null){
return result;
}
//递归的去右边找
return find(root.right,i);
}
private static int getheight(Node root) {
if(root==null){
return 0;
}
//递归计算左右子树的高度取其中大的加一就是整棵树的高度
int leftheiht=getheight(root.left);
int rightHeght=getheight(root.right);
return 1+(leftheiht>rightHeght?leftheiht:rightHeght);
}
private static int getKLeafSize(Node root,int k) {
if(root==null || k<1){
return 0;
}
if(k==1){
return 1;
}
//第K层的节点个数就为K-1层的左右子树的节点数之和
return getKLeafSize(root.left,k-1)+getKLeafSize(root.right,k-1);
}
public static int leafSize=0;
public static void getLeafSize(Node root) {
if(root==null){
return;
}
//遍历二叉树，如果但前节点是叶子节点就leafsize++
if(root.left==null && root.right==null){
leafSize++;
}
getLeafSize(root.left);
getLeafSize(root.right);
}
public static int count=0;
public static void getsize(Node root) {
if(root==null){
return;
}
count++;
getsize(root.left);
getsize(root.right);
}
//后序遍历
public static void postOrderTraversal(Node root) {
//左右根
if(root==null){
return;
}
//递归访问左子树
postOrderTraversal(root.left);
//递归访问右子树
postOrderTraversal(root.right);
//访问根节点
System.out.println(root.var);
return;
}
//中序遍历
public static void inOrderTraversal(Node root) {
//左根右
if(root==null){
return;
}
//递归访问左子树
inOrderTraversal(root.left);
//访问根节点
System.out.println(root.var);
//递归访问右子树
inOrderTraversal(root.right);
return;
}
//先序遍历
public static void preOrderTraversal(Node root) {
//根左右
if(root==null){
return;
}
//访问根节点
System.out.println(root.var);
//访问左子树
preOrderTraversal(root.left);
//访问右子树
preOrderTraversal(root.right);
return;
}
}
2.6二叉树的非递归遍历
import java.util.Stack;
class Node{
int var;
Node left;
Node right;
public Node(int var) {
this.var = var;
}
public static Node createBinaryTree(){
Node a=new Node(1);
Node b=new Node(2);
Node c=new Node(3);
Node d=new Node(4);
Node e=new Node(5);
Node f=new Node(6);
a.left=b;
a.right=c;
b.left=d;
b.right=e;
c.left=f;
return a;
}
}
public class levalTree {
public static void main(String[] args) {
Node root=Node.createBinaryTree();
//先序
// preOrderNoR(root);
//中序
// inOrderNoR(root);
//后序
postOrderNoR(root);
}
public static void postOrderNoR(Node root) {
if(root==null){
return;
}
//左右根
Stack<Node> stack=new Stack<>();
Node cur=root;
Node pre=null; //记录后序遍历中的前一个节点
while (true){
while (cur!=null){
stack.push(cur);
cur=cur.left;
}
if(stack.isEmpty()){
break;
}
Node top = stack.peek();
if(top.right==null || pre==top.right){
System.out.println(top.var);
stack.pop();
pre=top; //更换引用说明之前访问过了
}else {
cur=top.right;
}
}
}
public static void inOrderNoR(Node root) {
Stack<Node> stack=new Stack<>();
Node cur=root;
while (true){
while (cur!=null){
//一路向左进栈
stack.push(cur);
cur=cur.left;
}
if(stack.isEmpty()){
//如果栈为空，就跳出循环
break;
}
Node top=stack.pop();
System.out.println(top.var);
//修改引用，指向右子树
cur=top.right;
}
}
public static void preOrderNoR(Node root) {
if(root==null){
return;
}
Stack<Node> stack=new Stack<>();
stack.push(root);
while (!stack.isEmpty()){
Node cur=stack.pop();
System.out.println(cur.var);
//先右子树入栈
if(cur.right!=null){
stack.push(cur.right);
}
//后左子树入栈
if(cur.left!=null){
stack.push(cur.left);
}
}
}
}
2.7二叉树的层序遍历
import java.util.LinkedList;
import java.util.Queue;
class Node{
int var;
Node left;
Node right;
public Node(int var) {
this.var = var;
}
public static Node createBinaryTree(){
Node a=new Node(1);
Node b=new Node(2);
Node c=new Node(3);
Node d=new Node(4);
Node e=new Node(5);
Node f=new Node(6);
a.left=b;
a.right=c;
b.left=d;
b.right=e;
c.left=f;
return a;
}
}
public class levalTree {
public static void main(String[] args) {
Node root=Node.createBinaryTree();
//层序遍历二叉树
levelOrder(root);
}
public static void levelOrder(Node root) {
if(root==null){
return;
}
Queue<Node > queue=new LinkedList<>();
queue.offer(root);
while (true){
Node cur = queue.poll();
if(cur==null){
break;
}
//访问根节点操作
System.out.println(cur.var);
//左子树入队列
if(cur.left!=null){
queue.offer(cur.left);
}
//右子树入队列
if(cur.right!=null){
queue.offer(cur.right);
}
}
}
}
346
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
