a cup of Java!

## 快速排序与堆排序的Java实现（泛型）

### 快排

package quicksort;

import java.util.List;
import java.util.ListIterator;

public class QuickSort {

@SuppressWarnings("unchecked")
public static <E extends Comparable<? super E>> void sort(List<E> list) {
Object[] objs = list.toArray();
partition(objs, 0, objs.length-1);
ListIterator<E> iterator = list.listIterator();
for(int i=0; i<objs.length; ++i) {
iterator.next();
iterator.set((E)objs[i]);
}
}

private static void partition(Object[] objs, int left, int right) {
if(left >= right) return;
int i = left;
int j = right;
@SuppressWarnings("unchecked")
Comparable<Object> temp = (Comparable<Object>)objs[i];
while( i < j ) {
while(temp.compareTo(objs[j]) < 0 && i<j) --j;
if(i == j) break;
objs[i] = objs[j];
++i;
while(temp.compareTo(objs[i]) > 0 && i<j) ++i;
if(i == j) break;
objs[j] = objs[i];
--j;
}
objs[i] = temp;
partition(objs, left, i-1);
partition(objs, i+1, right);
}
}

### 堆排序

package heapsort;

import java.util.ArrayList;
import java.util.List;

public class HeapSort {

public static <E extends Comparable<? super E>> void sort(List<E> list) {
if(list == null || list.size() == 0) return;
Object[] a = list.toArray();
buildHeap(a);
int index = a.length-1;
while(index > 0) {
swap(a, 0, index);
--index;
reBuildHeap(a, 0, index);
}
print(a);
}

@SuppressWarnings("unchecked")
private static void reBuildHeap(Object[] a, int firstIndex, int lastIndex) {
int i = firstIndex;
int j = i*2 + 1;
while(j<=lastIndex) {
Comparable<Object> compAj = (Comparable<Object>)a[j];
if(j<lastIndex) {
if(compAj.compareTo(a[j+1]) < 0) {
++j;
compAj = (Comparable<Object>)a[j];
}
}
if(compAj.compareTo(a[i]) > 0) swap(a, i, j);
i = j;
j = i*2 + 1;
}
}

private static void buildHeap(Object[] a) {
int index = a.length-1;
index = (index-1)/2;
while( index >= 0) {
reBuildHeap(a, index, a.length-1);
--index;
}
}

private static void print(Object[] a) {
for(Object i:a) {
System.out.print(i + " ");
}
System.out.println();
}

private static void swap(Object[] a , int i, int j) {
Object temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}


#### 三种排序算法(归并排序、快速排序，堆排序)

2016-07-18 18:40:01

#### Java 实现 堆排序 快速排序 以及 TopK问题(二)

2016-09-13 13:42:00

#### 六大经典排序算法 java 选择排序、插入排序、冒泡排序、快速排序、堆排序、归并排序，六大经典排序算法，

2016-11-04 08:54:36

#### 泛型快速排序（java 语言实现）

2016-04-17 11:12:33

#### 常见比较排序算法的实现（归并排序、快速排序、堆排序、选择排序、插入排序、希尔排序）

2016-05-16 22:27:55

#### 冒泡排序、快速排序、堆排序（Java）

2017-08-12 23:01:57

#### 排序算法(归并排序, 快速排序, 堆排序)

2016-08-10 08:47:47

#### 快速排序和堆排序的使用场景比较

2016-12-16 15:35:03

#### Java ArrayList实现的快排，归并排序，堆排序

2013年10月16日 12KB 下载

#### 冒泡排序，选择排序，快速排序，堆排序与二分查找算法

2015-12-02 14:34:04