堆排序算法Java面向对象实现

堆排序算法介绍

堆是一种重要的数据结构，为一棵完全二叉树, 底层如果用数组存储数据的话，假设某个元素为序号为i(Java数组从0开始,i为0到n-1),如果它有左子树，那么左子树的位置是2i+1，如果有右子树，右子树的位置是2i+2，如果有父节点，父节点的位置是(n-1)/2取整。分为最大堆和最小堆，最大堆的任意子树根节点不小于任意子结点，最小堆的根节点不大于任意子结点。所谓堆排序就是利用堆这种数据结构来对数组排序，我们使用的是最大堆。处理的思想和冒泡排序，选择排序非常的类似，一层层封顶，只是最大元素的选取使用了最大堆。最大堆的最大元素一定在第0位置，构建好堆之后，交换0位置元素与顶即可。堆排序为原位排序(空间小), 且最坏运行时间是O(nlgn)，是渐进最优的比较排序算法。

实现思路

堆排序简单来说可以概括为三个步骤：
1.根据数据建立无序的堆
2.对堆按大顶堆或小顶堆调整。大顶堆即是满足树中根节点的值始终大于孩子节点的值，局部也满足这个条件，小顶堆相反。
3.每一次调整过后再顶部得到这些数据的最大值或最小值，出堆，并把最后一个节点放到顶部，以此循环，直到堆里的数据全部给出。

具体代码

堆排序类

public class HeapSort<T extends Comparable<T>> {    private List<T> sub;// 排序资源列表    private Integer listLength = 0;// 元素个数    private Integer nodeNum = 0;// 堆中节点个数    private Node top;// 顶节点    private Node end;// 最后一个节点    private Node end2;// 倒数第二个节点    private List<T> result = new ArrayList<T>();//排序结果    public HeapSort(List<T> srcList) {        this.nodeNum = 1;        this.top = new Node((T)srcList.get(0), 1, 1);// 顶节点默认层数为1，编号为1        this.sub = srcList.subList(1, srcList.size());        this.listLength = srcList.size();        this.end = null;        createHeap(this.top);    }    // 创建堆    private void createHeap(Node h) {        if (sub == null || sub.size() <= 0) {            return;        }        // 添加左孩子        createLeftChild(h);        // 添加右孩子        createRightChild(h);        return;    }    // 创建左孩子    private void createLeftChild(Node h) {        if (h.getLeft() != null) {            return;        }        if (listLength >= h.getNum().intValue() * 2) {// 可以有左孩子            nodeNum++;            Node leftChild = new Node((T)sub.get(0), h.getFloor() + 1, h.getNum() * 2);            h.setLeft(leftChild);            leftChild.setParent(h);            if (leftChild.getNum() == listLength) {// 最后一个节点                end = leftChild;            }            sub = sub.subList(1, sub.size());            createHeap(leftChild);        }else{            end = h;        }        return;    }    // 创建右孩子    private void createRightChild(Node h) {        if (h.getRight() != null) {            return;        }        if (listLength >= h.getNum().intValue() * 2 + 1) {// 可以有右孩子            nodeNum++;            Node rightChild = new Node((T)sub.get(0), h.getFloor() + 1, h.getNum() * 2 + 1);            h.setRight(rightChild);            rightChild.setParent(h);            if (rightChild.getNum() == listLength) {// 最后一个节点                end = rightChild;            }            sub = sub.subList(1, sub.size());            createHeap(rightChild);        }        return;    }    /**     * 调整大顶堆，并且返回最顶端的值     * @param h 根节点     * @return     */    private T adjustMaxHeap(Node h) {        // 通过迭代遍历根节点和孩子节点，调整为根节点最大        if (h == null) {            return null;        }        if(nodeNum==1){            return (T) top.getValue();        }        if (h.getNum().equals(nodeNum - 1)) {// 调整堆的时候添加上倒数第二个节点的引用，以便删除最后一个节点后将end指向此节点            end2 = h;        }        T top = (T) h.getValue();        // 调整左孩子        T maxLeft = adjustMaxHeap(h.getLeft());        // 调整右孩子        T maxRight = adjustMaxHeap(h.getRight());        if (maxLeft == null && maxRight == null) {// 没有左右孩子            return (T) h.getValue();        } else if (maxLeft == null && maxRight != null) {// 没有左孩子            if (maxRight.compareTo(top)>0) {                h.setValue(maxRight);                h.getRight().setValue(top);            }        } else if (maxLeft != null && maxRight == null) {// 没有右孩子            if (maxLeft.compareTo(top)>0) {                h.setValue(maxLeft);                h.getLeft().setValue(top);            }        } else {// 有左右孩子            if (maxLeft.compareTo(top)>0 || maxRight.compareTo(top)>0) {                if (maxLeft.compareTo(maxRight)>=0) {// 左孩子最大                    h.setValue(maxLeft);                    h.getLeft().setValue(top);                } else {// 右孩子最大                    h.setValue(maxRight);                    h.getRight().setValue(top);                }            }        }        return (T) h.getValue();    }    /**     * 堆排序方法(大顶堆)     * @param srcList     * @return     */    public List<T> sort() {        // 循环调整堆        while (floorMoreOne()) {            T max = adjustMaxHeap(top);            //stack.push(max);            result.add((T) max);            top.setValue(end.getValue());            Node parent = end.getParent();            if (end.getParent() == null) {                break;            }            if (parent.getLeft() != null && parent.getLeft().getNum().intValue() == end.getNum().intValue()) {                parent.setLeft(null);            }            if (parent.getRight() != null && parent.getRight().getNum().intValue() == end.getNum().intValue()) {                parent.setRight(null);            }            nodeNum--;            end = end2;            // end指向倒数第二个节点        }        result.add((T) top.getValue());        return result;    }    // 判断堆的层数是否大于一    private boolean floorMoreOne() {        if (top.getLeft() != null || top.getRight() != null) {            return true;        }        return false;    }}

节点类

public class Node<T> {    private T value;// 节点的值    private Integer floor;// 节点所在层    private Integer num;// 节点编号    private Node parent;// 父节点    private Node left;// 左孩子    private Node right;// 右孩子    public Node() {    }    public Node(T value) {        super();        this.value = value;    }    public Node(T value, Integer floor) {        super();        this.value = value;        this.floor = floor;    }    public Node(T value, Integer floor, Integer num) {        super();        this.value = value;        this.floor = floor;        this.num = num;    }    public Node<T> getLeft() {        return left;    }    public Integer getNum() {        return num;    }    public void setLeft(Node leftChild) {        this.left = leftChild;    }    public void setRight(Node rightChild) {        this.right = rightChild;    }    public void setParent(Node h) {        this.parent = h;    }    public int getFloor() {        return floor;    }    public T getValue() {        return value;    }    public Node getRight() {        return right;    }    public void setValue(T value) {        this.value = value;    }    public Node getParent() {        return parent;    }}

这个实现中用到了泛型，可以对多种类型排序，只需要实现comparable接口并实现了compareTo方法。

测试代码

public void test01(){        @SuppressWarnings("unchecked")        int j=0;        String[] strs = new String[1000];        while(j<strs.length){            int len = (int) Math.floor(Math.random()*10+1);            byte[] bytes = new byte[len];            for(int k=0;k<len;k++){                bytes[k] = (byte) Math.floor(Math.random()*26+65);            }            strs[j] = new String(bytes);            j++;        }        HeapSort<String> sort = new HeapSort<String>((List<String>)Arrays.asList(strs));        List<String> list1 = sort.sort();        for(String o:list1){            if(list1.indexOf(o)%10==0){                System.out.println(o.toString()+" ");            }else{                System.out.print(o.toString()+" ");            }        }    }

测试结果

这个实例是纯java面向对象的实现，相比较原生面向过程的实现处理速度回慢，占用资源也多，进攻学习用。如果有什么问题，希望道友们慷慨指正。