顺序二叉树

顺序二叉树

树：
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做数是因为它看起来像是一棵倒挂的数，根朝上叶子朝下。
特点：每个结点有零个或者多个子结点；没有父结点的结点称为根节点；每个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树。
节点的度：一个节点含有的子树的个数称为该节点的度；
叶节点或终端节点：度为0的节点称为叶节点；
非终端节点或分支节点：度不为0的节点；
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
兄弟节点：具有相同父节点的节点互称为兄弟节点；
树的度：一棵树中，最大的节点的度称为树的度；
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；
堂兄弟节点：双亲在同一层的节点互为堂兄弟；
节点的祖先：从根到该节点所经分支上的所有节点；
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。
森林：由m（m>=0）棵互不相交的树的集合称为森林；
二叉树
一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树的特点：

1. 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。
2. 二叉树的子树有左右之分，其子树的次序不能颠倒。

顺序二叉树：
顺序结构存储就是使用数组来储存，一般使用数组只适合表示完全二叉树，因为不完全二叉树会有空间的浪费。
二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。
父推子：左孩子2n+1 右孩子 2n+2 子推父：（n-1）/2

public interface IHeap {
//从每颗子树的根节点开始调整 调整的长度为len
void AdjustDown(int root,int len);
//初始化建立大根堆
public void initHeap(int[] array);
//向上调整，从孩子节点开始调整
void AdjustUp(int child,int len);
// 插入 item 到堆中
void pushHeap(int item);
// 返回堆顶元素，删除数据元素
int popHeap();
// 返回堆顶元素，不删除数据元素
int getHeapTop();
//堆排序
void HeapSort();
//打印堆
void show();
}

import java.util.Arrays;
public class TestHeap implements IHeap {

    private int[] elem;
    private  int usedSize;
    private static final  int DEFAULT_SIZE = 10;

    public TestHeap(){
        this.elem = new int[DEFAULT_SIZE];
        this.usedSize = 0;
    }

    @Override
    public void AdjustDown(int root, int len) {
        int parent = root;
        int child = 2*parent + 1;
        while(child < len){
            if(child+1 < len &&this.elem[child] < this.elem[child+1]){//有右孩子
                ++child;
            }
            if(elem[child] > elem[parent]){
                int tmp = elem[child];
                elem[child] = elem[parent];
                elem[parent] = tmp;
                parent= child;
                child = 2 * parent + 1;
            }else {
                break;
            }
        }
    }

    @Override
    public void initHeap(int[] array) {
        for (int i = 0; i <array.length ; i++) {
           this.elem[i] = array[i];
           this.usedSize++;
        }
        for (int i = ((this.elem.length-1-1)/2); i >= 0 ; i--) {
            AdjustDown(i,this.usedSize);
        }

    }

    @Override
    public void AdjustUp(int child, int len) {
        int parent = (child-1)/2;
        while(child > 0){
            if(this.elem[child] > this.elem[parent]){
                int tmp = this.elem[child];
                this.elem[child] = this.elem[parent];
                this.elem[parent] = tmp;
                child = parent;
                parent = (child-1)/2;
            }else {
                break;
            }
        }
    }
    private boolean isFull(){
        return  this.usedSize == this.elem.length;
    }
    @Override
    public void pushHeap(int item) {
        if(isFull()){
            this.elem = Arrays.copyOf(this.elem,2*this.elem.length);
        }
        this.elem[this.usedSize] = item;
        this.usedSize++;
        AdjustUp(this.usedSize-1,this.usedSize);
    }

    @Override
    public int popHeap() {
        if(this.usedSize == 0){
          throw new UnsupportedOperationException("堆为空");
        }
       int tmp = this.elem[0];
       this.elem[0] = this.elem[this.usedSize-1];
       this.elem[usedSize-1] = tmp;
        this.usedSize--;
       AdjustDown(0,this.usedSize);
       return 0;
    }

    @Override
    public int getHeapTop() {
        if(this.usedSize == 0){
            throw new UnsupportedOperationException("堆为空");
        }
        return this.elem[0];
    }

    @Override
    public void HeapSort() {
        int end = this.usedSize-1;
        while (end > 0){
            int tmp = this.elem[0];
            this.elem[0] = this.elem[end];
            this.elem[end] = tmp;
            AdjustDown(0,end);
            end--;
        }
    }

    @Override
    public void show() {
        for (int i = 0; i <this.usedSize ; i++) {
            System.out.print(this.elem[i]+" ");
        }
        System.out.println();
    }
}

测试用例：

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        TestHeap testHeap = new TestHeap();
        testHeap.initHeap(array);
        testHeap.show();
        testHeap.pushHeap(11);
        testHeap.show();
        testHeap.popHeap();
        testHeap.show();
        System.out.println(testHeap.getHeapTop());
        testHeap.HeapSort();
        testHeap.show();
    }
}

测试结果：
9 8 7 4 5 6 3 2 1
11 9 7 4 8 6 3 2 1 5
9 8 7 4 5 6 3 2 1
9
1 2 3 4 5 6 7 8 9