快速排序与堆排序的Java实现(泛型)

原创 2016年08月31日 15:56:44

快速排序与堆排序的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);
    }
}

堆排序

堆排序特别适合在大数据下,选出topK的情况

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;
    }
}
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

用Java泛型实现快速排序

package ch10; public class QuickSort { /** * successfully-快速排序 * 使用了泛型-自然排序 * @param * @p...

泛型快速排序(java 语言实现)

快速排序基本思想:http://blog.csdn.net/stushan/article/details/51172253实现 Comparable 类型和定制类型的比较(要定义比较器)packag...
  • stuShan
  • stuShan
  • 2016年04月17日 11:12
  • 291

C语言编写的泛型快速排序算法

  • 2012年08月04日 22:29
  • 316KB
  • 下载

利用C实现泛型(generics)效果---原地洗牌,快速排序

用一个函数实现一个算法,能够应用在不同的数据类型(int,double,字符数组)上,这在C++,python等高级语言中是很常见的。 灵活地利用C中的void指针,内存操作,函数指针也可以实现类似的...

快速排序与堆排序的C++实现

  • 2013年08月17日 06:55
  • 259KB
  • 下载

c++实现堆排序和快速排序比较

  • 2014年10月30日 11:26
  • 5KB
  • 下载

C++泛型编程 快速排序的函数模板实现

说在前面的废话话说快一年没写过博客了。。。 在建站之前就先用csdn写吧这次要说的东西也没有啥,主要是想写一次快排(学了这么就快排都没写过你敢信用法类似于stl里面的sort,有两个版本。不知道为什...

冒泡、插入、归并、堆排序、快速排序的Java实现代码

import java.util.Arrays; public class Sort { static int swapTimes=0; public static void main(S...

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

接上文 已知快速排序可以将一个数组分成两部分,一部分大于某个值,一部分小于某个值,那么由这点可以推出取TopK值的方法如下: 假设快排每一趟的分割值的点为p,数组长度为n,那么需要...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:快速排序与堆排序的Java实现(泛型)
举报原因:
原因补充:

(最多只允许输入30个字)