堆排序:利用大根堆

数组全部入堆,再出堆从后向前插入回数组中,数组就从小到大有序了。

public class MaxHeap<T extends Comparable<? super T>> {
private T[] data;
private int size;
private int capacity; public MaxHeap(int capacity) {
this.data = (T[]) new Comparable[capacity + 1];
size = 0;
this.capacity = capacity;
} public int size() {
return this.size;
} public boolean isEmpty() {
return size == 0;
} public int getCapacity() {
return this.capacity;
} /**
* @return 查看最大根(只看不删, 与popMax对比)
*/
public T seekMax() {
return data[1];
} public void swap(int i, int j) {
if (i != j) {
T temp = data[i];
data[i] = data[j];
data[j] = temp;
}
} public void insert(T item) {
size++;
data[size] = item;
shiftUp(size);
} /**
* @return 弹出最大根(弹出意味着删除, 与seekMax对比)
*/
public T popMax() {
swap(1, size--);
shiftDown(1);
return data[size + 1];
} /**
* @param child 孩子节点下角标是child,父节点下角表是child/2
*/
public void shiftUp(int child) {
while (child > 1 && data[child].compareTo(data[child / 2]) > 0) {
swap(child, child / 2);
child = child / 2;
}
} /**
* @param a data数组中某个元素的下角标
* @param b data数组中某个元素的下角标
* @return 哪个元素大就返回哪个的下角标
*/
private int max(int a, int b) {
if (data[a].compareTo(data[b]) < 0) {//如果data[b]大
return b;//返回b
} else {//如果data[a]大
return a;//返回a
}
} /**
* @param a data数组中某个元素的下角标
* @param b data数组中某个元素的下角标
* @param c data数组中某个元素的下角标
* @return 哪个元素大就返回哪个的下角标
*/
private int max(int a, int b, int c) {
int biggest = max(a, b);
biggest = max(biggest, c);
return biggest;
} /**
* @param father 父节点下角标是father,左右两个孩子节点的下角表分别是:father*2 和 father*2+1
*/
public void shiftDown(int father) {
while (true) {
int lchild = father * 2;//左孩子
int rchild = father * 2 + 1;//右孩子
int newFather = father;//newFather即将更新,父、左、右三个结点谁大,newFather就是谁的下角标 if (lchild > size) {//如果该father结点既没有左孩子,也没有右孩子
return;
} else if (rchild > size) {//如果该father结点只有左孩子,没有右孩子
newFather = max(father, lchild);
} else {//如果该father结点既有左孩子,又有右孩子
newFather = max(father, lchild, rchild);
} if (newFather == father) {//说明father比两个子结点都要大,表名已经是大根堆,不用继续调整了
return;
} else {//否则,还需要继续调整堆,直到满足大根堆条件为止
swap(father, newFather);//值进行交换
father = newFather;//更新father的值,相当于继续调整shiftDown(newFather)
}
}
} public static <T extends Comparable<? super T>> void sort(T[] arr) {
int len = arr.length;
//入堆
MaxHeap<T> maxHeap = new MaxHeap<T>(len);
for (int i = 0; i < len; i++) {
maxHeap.insert(arr[i]);
}
//出堆
for (int i = len - 1; i >= 0; i--) {
arr[i] = maxHeap.popMax();
}
} public static void printArr(Object[] arr) {
for (Object o : arr) {
System.out.print(o);
System.out.print("\t");
}
System.out.println();
} public static void main(String args[]) {
Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};
printArr(arr);//3 5 1 7 2 9 8 0 4 6
sort(arr);
printArr(arr);//0 1 2 3 4 5 6 7 8 9
}
}

堆排序:对数组进行构造堆(最大堆)

public class MaxHeap<T extends Comparable<? super T>> {
private T[] data;
private int size;
private int capacity; public MaxHeap(int capacity) {
this.capacity = capacity;
this.size = 0;
this.data = (T[]) new Comparable[capacity + 1];
} public MaxHeap(T[] arr) {//heapify,数组建堆
capacity = arr.length;
data = (T[]) new Comparable[capacity + 1];
System.arraycopy(arr, 0, data, 1, arr.length);
size = arr.length;
for (int i = size / 2; i >= 1; i--) {
shiftDown(i);
}
} public int size() {
return this.size;
} public int getCapacity() {
return this.capacity;
} public boolean isEmpty() {
return size == 0;
} public T seekMax() {
return data[1];
} public void swap(int i, int j) {
if (i != j) {
T temp = data[i];
data[i] = data[j];
data[j] = temp;
}
} public void insert(T item) {
size++;
data[size] = item;
shiftUp(size);
} public T popMax() {
swap(1, size--);
shiftDown(1);
return data[size + 1];
} public void shiftUp(int child) {
while (child > 1 && data[child].compareTo(data[child / 2]) > 0) {
swap(child, child / 2);
child /= 2;
}
} /**
* @param a data数组中某个元素的下角标
* @param b data数组中某个元素的下角标
* @return 哪个元素大就返回哪个的下角标
*/
private int max(int a, int b) {
if (data[a].compareTo(data[b]) < 0) {//如果data[b]大
return b;//返回b
} else {//如果data[a]大
return a;//返回a
}
} /**
* @param a data数组中某个元素的下角标
* @param b data数组中某个元素的下角标
* @param c data数组中某个元素的下角标
* @return 哪个元素大就返回哪个的下角标
*/
private int max(int a, int b, int c) {
int biggest = max(a, b);
biggest = max(biggest, c);
return biggest;
} public void shiftDown(int father) {
while (true) {
int lchild = father * 2;
int rchild = father * 2 + 1;
int newFather = father;//这里赋不赋值无所谓,如果把下面这个return改成break,那就必须赋值了 if (lchild > size) {//如果没有左、右孩子
return;
} else if (rchild > size) {//如果没有右孩子
newFather = max(father, lchild);
} else {//如果有左、右孩子
newFather = max(father, lchild, rchild);
} if (newFather == father) {//如果原父结点就是三者最大,则不用继续整理堆了
return;
} else {//父节点不是最大,则把大的孩子交换上来,然后继续往下堆调整,直到满足大根堆为止
swap(newFather, father);
father = newFather;//相当于继续shiftDown(newFather)。假如newFather原来是father的左孩子,那就相当于shiftDown(2*father)
}
}
} public static <T extends Comparable<? super T>> void sort(T[] arr) {
int len = arr.length;
MaxHeap<T> maxHeap = new MaxHeap<>(arr);
for (int i = len - 1; i >= 0; i--) {
arr[i] = maxHeap.popMax();
}
} public static void printArr(Object[] arr) {
for (Object o : arr) {
System.out.print(o);
System.out.print("\t");
}
System.out.println();
} public static void main(String args[]) {
Integer[] arr = {3, 5, 1, 7, 2, 9, 8, 0, 4, 6};
printArr(arr);//3 5 1 7 2 9 8 0 4 6
sort(arr);
printArr(arr);//0 1 2 3 4 5 6 7 8 9
}
}

  

堆排序(Java数组实现)的更多相关文章

  1. Java 数组

    数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同. Java语言中提供的数组是用来存储固定大小的同类型元素. 你可以声明一个数组变量,如numbers[100 ...

  2. 第5章 Java数组

    1.什么是数组 数组可以想象成一个巨大的盒子,这个盒子里面存放的是同一个数据类型的数据 例如:int[] scores = {78,68,94,93}; 2.如何使用Java中的数组 2.1申明数组 ...

  3. Java 数组基础

    数组 数组(Array):相同类型数据的集合. 定义数组 方式1(推荐,更能表明数组类型) type[] 变量名 = new type[数组中元素的个数]; 比如: int[] a = new int ...

  4. Java数组及其内存分配

    几乎所有的程序设计语言都支持数组.Java也不例外.当我们需要多个类型相同的变量的时候,就考虑定义一个数组.在Java中,数组变量是引用类型的变量,同时因为Java是典型的静态语言,因此它的数组也是静 ...

  5. [转载]Java数组扩容算法及Java对它的应用

    原文链接:http://www.cnblogs.com/gw811/archive/2012/10/07/2714252.html Java数组扩容的原理 1)Java数组对象的大小是固定不变的,数组 ...

  6. Java数组技巧攻略

      Java数组技巧攻略 0.  声明一个数组(Declare an array) String[] aArray = new String[5]; String[] bArray = {" ...

  7. Java数组扩容算法及Java对它的应用

    1)Java数组对象的大小是固定不变的,数组对象是不可扩容的.利用数组复制方法可以变通的实现数组扩容.System.arraycopy()可以复制数组.Arrays.copyOf()可以简便的创建数组 ...

  8. Java数组与vector互转

    Java数组与vector互转 /* Object[] object1 = null ; //数组定义 Vector<Object> object2;//Vector定义 object2 ...

  9. 比较Java数组,ArrayList,LinkedList,Vector 性能比较

    public class PerformanceTester { public static final int TIMES=100000; public static abstract class ...

随机推荐

  1. Flask Ansible自动化平台搭建(持续更新)

    一:简介 使用Ansible + Flask + Celery搭建web平台. 目录结构 . ├── ansible_api │   ├── ansible_playbook_inventory.py ...

  2. linux nginx常见问题及优化,压力测试,tomcat服务器优化

    nginx常见问题 nginx优化全局配置优化[root@web2 nginx]# vim conf/nginx.confuser nobody;worker_processes 1;(与cpu核心数 ...

  3. Jpa中设置OneToMany插入报异常解决办法

    在Jpa中如果设置@OneToMany,但使用的时候,如果没有赋值,会报异常出现,这时只需要实例化一个空数组即可, 但类型一定要对应: 实例如下: newField.setxxxxxList(new ...

  4. js中reduce()用法

    reduce()方法 定义:reduce()接收一个函数作为累加器,数组中每个值(从左到右)开始缩减,最终计算为一个值 对于空数组不执行回调函数 语法:array.reduce(function(to ...

  5. FMECA分析

    FMECA是针对产品所有可能的故障,并根据对故障模式的分析,确定每种故障模式对产品工作的影响,找出单点故障,并按故障模式的严重度及其发生概率确定其危害性.所谓单点故障指的是引起产品故障的,且没有冗余或 ...

  6. java.lang.NullPointerException: No FileItemFactory has been set.

    1.错误描述 java.lang.NullPointerException: No FileItemFactory has been set. at org.apache.commons.fileup ...

  7. .Net Core从命令行读取配置文件

    最近在学习博客园腾飞(jesse)的.Net Core视频教程,收益匪浅,在此作推荐 : http://video.jessetalk.cn/ 言归正传,.Net Core应用程序中如何通过命令行读取 ...

  8. Query 插件为什么要return this.each()

    jQuery.fn.test2= function(){ this.css("background","#ff0");//这里面的this为jquery对象,而 ...

  9. Hibernate【与Spring整合】

    前言 前面已经学习了如何使用Spring与Struts2进行整合,本博文主要讲解如何使用Spring对Hibernate进行整合 Spring和Hibernate整合的关键点: SessionFact ...

  10. n人围成一圈报数

    题目:有n个人围成一圈,顺序排号.从第一个人开始报数(从1到3报数),凡报到3的人退出圈子,问最后留下的是原来的第几号的那位 思路:用一个数组存这n个人,里面的初始状态全设为1,表示都还在圈子里面. ...