java实现排序(4)-堆排序

最新推荐文章于 2024-07-14 22:24:20 发布
最新推荐文章于 2024-07-14 22:24:20 发布
阅读量493 收藏 2
点赞数
分类专栏： 算法 文章标签： 堆排序 java 效率 测试 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012403290/article/details/71171061
版权
本文详细介绍了如何在Java中使用堆排序算法，并对比了两种不同的数据插入方法及存储方式对效率的影响。通过实验得出，直接构建二叉堆并调整的效率高于逐个插入元素，且直接在原数组存储排序结果更高效。
摘要由CSDN通过智能技术生成

引言

在上一篇博文中，尝试实现了二叉堆的结构。在本篇博文中，将建立在堆的基础之上，讨论如何用堆实现排序。二叉堆的代码直接引用昨天的实现源码，在代码的基础上做一些修改使其变成堆排序。笔者目前整理的一些blog针对面试都是超高频出现的。大家可以点击链接：http://blog.csdn.net/u012403290

二叉堆源码

如果对二叉堆不是很了解，可以查阅相关资料，或者阅读一下我写的这篇文章《java实现-堆》，地址是：http://blog.csdn.net/u012403290/article/details/71126768

下面是上篇博文二叉堆的实现源码：


package com.brickworkers;

public class Heap<T extends Comparable<? super T>> {

    private static final int DEFAULT_CAPACITY = 10; //默认容量

    private T[] table; //用数组存储二叉堆

    private int size; //表示当前二叉堆中有多少数据

    public Heap(int capactiy){
        this.size = 0;//初始化二叉堆数据量
        table = (T[]) new Comparable[capactiy + 1];//+1是因为我们要空出下标为0的元素不存储
    }

    public Heap() {//显得专业些，你就要定义好构造器
        this(DEFAULT_CAPACITY);
    }


    //插入
    public void insert(T t){
        //先判断是否需要扩容
        if(size == table.length - 1){
            resize();
        }
        //开始插入
        //定义一个预插入位置下标
        int target = ++size;
        //循环比较父节点进行位置交换
        for(table[ 0 ] = t; t.compareTo(table[target/2]) < 0; target /= 2){
            table[target] = table[target/2];//如果满足条件，那么两者交换，知道找到合适位置（上滤）
        }
        //插入数据
        table[target] = t;
        print();

    }


    //删除最小
    //删除过程中，需要重新调整二叉堆（下滤）
    public void deleteMin(){
        if(size == 0){
            throw new IllegalAccessError("二叉堆为空");
        }

        //删除元素
        table[1] = table[size--];

        int target  = 1;//从顶部开始重新调整二叉堆

        int child;//要处理的节点下标
        T tmp = table[ target ];

        for( ; target * 2 <= size; target = child )
        {
            child = target * 2;
            if( child != size &&table[ child + 1 ].compareTo( table[ child ] ) < 0 ){//如果右孩子比左孩子小
                child++;
            }
            if( table[ child ].compareTo( tmp ) < 0 ){
                table[ target ] = table[ child ];
                table[child] = null;
            }
            else{
                 break;
            }
        }
        table[ target ] = tmp;

        print();
    }





    //如果插入数据导致达到数组上限，那么就需要扩容
    private void resize(){
          T [] old = table;
          table = (T [])  new Comparable[old.length*2 + 1];//把原来的数组扩大两倍
          for( int i = 0; i < old.length; i++ )
              table[ i ] = old[ i ];        //数组进行拷贝
    }


    //打印数组
    private void print(){
        System.out.println();
        for (int i = 1; i <= size; i++) {
            System.out.print(table[i] + " ");
        }
        System.out.println("二叉堆大小:"+size);
    }


    public static void main(String[] args) {
        Heap<Integer> heap = new Heap<>();

        //循环插入0~9的数据
        for (int i = 0; i < 10; i++) {
            heap.insert(i);
        }

        //循环删除3次，理论上是删除0,1,2 
        for (int i = 0; i < 3; i++) {
            heap.deleteMin();
        }
    }

}

思考

因为二叉堆中在堆顶，要么是最大值，要么是最小值。我们每次进行一次deleteMin（deleteMax）就可以把这个数据存储起来，一直到二叉堆删除结束。那么，我们考虑两个方面：①如何把数据放入二叉堆；②如何把排好序的数据提取出来。

对于第一个问题，如何把数据放入二叉堆，最简单的就是可以调用二叉堆的insert方法，把要排序的数据一个个放入其中，或者优雅一些，我们在源码中新增一个构造函数，直接入参一个数组，直接转化成二叉树。那或许有的小伙伴又要问了，这个优雅不优雅有必要吗？构造函数里面进行insert操作？不！我们不在构造函数中调用insert操作（但是在源码中，我们还是要进行比较），我们可以直接把所有数据全部插入，然后在把它整个调整成二叉堆。在后面的代码中，我们将比较这两者的优劣。

对于第二个问题，其实也有两种解决办法，第一种是我们创立一个新的数组，这个数组核心功能就是接收二叉堆删除的数据，这样一来，直到二叉堆删除结束，那么这个数组就是排序好了的数据，实现了数据存储和提取。第二种，就显得要高明一点点，我们试想，在二叉堆的实现过程中，我们本身就是用数组来实现的。而且，在上篇博文中，我们讨论它的删除的时候，最后一个元素的位置肯定会变动，所以，这种情况下，我们完全可以在二叉堆删除堆顶元素的时候，把删除的数据存储在最后一个元素的位置。这么一来在二叉堆删除结束的时候，那么这个原本表示二叉堆的数组已经是有序的了。

新增一个接收数组的构造函数

以下的所有代码，都是建立在上述的二叉堆源码上进行修改的。

1、接收数组的第一种方式：


    //实现方式一，直接用insert来实现数据放入二叉堆中
    public Heap(T[] array){
        super();
        for (T t : array) {
            insert(t);//直接调用二叉堆的insert方法进行插入
        }
    }

第二种方式，我们先把数据全部随意插入到数组中，然后把数组调整成二叉堆。如何调整呢？在上一篇博文中，我们在删除的情况下，我们需要通过下滤的方式从新调整二叉堆，其实思想是一样的，只是删除的时候调整从最上层开始，而在这里我们从最下层（标准来说是倒数第二层）开始。下图表达了操作过程：
这里写图片描述

在源码中，我把删除节点后面的重新调整二叉堆抽离了出来：

    private void dealHeap(int target) {
        int child;//要处理的节点下标
        T tmp = table[ target ];

        for( ; target * 2 <= size; target = child )
        {
            child = target * 2;
            if( child != size &&table[ child + 1 ].compareTo( table[ child ] ) < 0 ){//如果右孩子比左孩子小
                child++;
            }
            if( table[ child ].compareTo( tmp ) < 0 ){
                table[ target ] = table[ child ];
                table[child] = null;
            }
            else{
                 break;
            }
        }
        table[ target ] = tmp;
    }

2、下面就是第二种实现放置，把数据全部放进去然后调整二叉堆：

public Heap( T [ ] array )
    {
            size = array.length;
            array = (T[]) new Comparable[ size + 2 ];//存储的数组要略微长
            for (int i = 0; i < array.length; i++) {
                table[ i++ ] = array[i];
            }
            //到这里为止，数据已经全部都放入了table中
            //接下来要做的就是要把这些数据转变成二叉堆
            for(int i = size/2; i > 0; i--){//从倒数第一个有儿子的节点开始处理
                dealHeap(i);
            }
    }

新增有序数据存储

1、第一种实现，我们在二叉堆中新增一个resultTable，接收每次删除的数据：


//成员变量
    private T[] resultTable;//用于存储有序数据（每次删除的数据就放入其中）

//修改构造函数，确认好存储数组的长度
resultTable = (T[]) new Comparable[ size ];//指定存储数组大小


//在resultTable末端添加数据
    //把数据插入到resultTable末端
    private void insertResult(T t){
        resultTable[resultTable.length - size] = t;
    }


//在delateMin方法中，把insertResult方法加入其中，使得每次删除的时候，就把数据移除出来

2、不新增数组直接把要删除的数据放到二叉堆数组的最末端，为什么可以如此做，在思考模块已经表述过了。

    //删除最小
    //删除过程中，需要重新调整二叉堆（下滤）
    public void deleteMin(){
        if(size == 0){
            throw new IllegalAccessError("二叉堆为空");
        }

//      //把删除的元素放入resultTable中
//      insertResult(table[1]);

        //把要删除的数据先存储起来
        T temp = table[1];

        //删除元素
        table[1] = table[size--];
        //把要删除的数据放到末尾
        table[size -- ] = temp;

        int target  = 1;//从顶部开始重新调整二叉堆

        dealHeap(target);
        print();
    }

这样一来，最后打印的时候，就可以直接打印二叉堆数组，不过这个时候的二叉堆不存在了。

效率比较

在上面所有的描述中，存在许多情况，接下来我们对他们进行比较，看看哪种效率会更高：

1、比较是把目标排序数组一个个insert块还是直接放入数组在调整二叉堆快
在测试过程中，我们保证存储数据一致，都采用额外的数组存储。
下面是我比较的源码和结果：

package com.brickworkers;

public class Heap<T extends Comparable<? super T>> {

    private static final int DEFAULT_CAPACITY = 10; //默认容量

    private T[] table; //用数组存储二叉堆

    private T[] resultTable;//用于存储有序数据（每次删除的数据就放入其中）

    private int size; //表示当前二叉堆中有多少数据

    public Heap(int capactiy){
        this.size = 0;//初始化二叉堆数据量
        table = (T[]) new Comparable[capactiy + 1];//+1是因为我们要空出下标为0的元素不存储
    }

    public Heap() {//显得专业些，你就要定义好构造器
        this(DEFAULT_CAPACITY);
    }


    //实现方式二，直接先插入，然后对数据进行整理成二叉堆
    public Heap( T [ ] array , boolean methodType){
        if(methodType){
            size = 0;
            table = (T[]) new Comparable[DEFAULT_CAPACITY + 1];
            //实现方式一，直接用insert来实现数据放入二叉堆中
            long insertStratTime = System.currentTimeMillis();
            for (T t : array) {
                    insert(t);
            }
            System.out.println("直接插入的方式耗时："+(System.currentTimeMillis() - insertStratTime));
        }else{
            size = array.length;
            table = (T[]) new Comparable[ size + 2 ];//存储的数组要略微长
            long dealHeapStratTime = System.currentTimeMillis();
            for (int i = 0; i < array.length; i++) {
                table[ i+1] = array[i];//arr[0]位置不存放数据
            }
            //到这里为止，数据已经全部都放入了table中
            //接下来要做的就是要把这些数据转变成二叉堆
            for(int i = size/2; i > 0; i--){//从倒数第二层开始处理
                dealHeap(i);
            }
            System.out.println("随机插入重新调整的方式耗时："+(System.currentTimeMillis() - dealHeapStratTime));
        }
         resultTable = (T[]) new Comparable[ size ];//指定存储数组大小    
    }


    //插入
    public void insert(T t){
        //先判断是否需要扩容
        if(size == table.length - 1){
            resize();
        }
        //开始插入
        //定义一个预插入位置下标
        int target = ++size;
        //循环比较父节点进行位置交换
        for(table[ 0 ] = t; t.compareTo(table[target/2]) < 0; target /= 2){
            table[target] = table[target/2];//如果满足条件，那么两者交换，知道找到合适位置（上滤）
        }
        //插入数据
        table[target] = t;
        print();

    }


    //删除最小
    //删除过程中，需要重新调整二叉堆（下滤）
    public void deleteMin(){
        if(size == 0){
            throw new IllegalAccessError("二叉堆为空");
        }

//      //把删除的元素放入resultTable中
        insertResult(table[1]);

        //把删除的元素放到末尾
//      T temp = table[1];

        //删除元素
        table[1] = table[size--];

//      table[size -- ] = temp;

        int target  = 1;//从顶部开始重新调整二叉堆

        dealHeap(target);


        print();
    }

    private void dealHeap(int target) {
        int child;//要处理的节点下标
        T tmp = table[ target ];

        for( ; target * 2 <= size; target = child )
        {
            child = target * 2;
            if( child != size &&table[ child + 1 ].compareTo( table[ child ] ) < 0 ){//如果右孩子比左孩子小
                child++;
            }
            if( table[ child ].compareTo( tmp ) < 0 ){
                table[ target ] = table[ child ];
                table[child] = null;
            }
            else{
                 break;
            }
        }
        table[ target ] = tmp;
    }





    //如果插入数据导致达到数组上限，那么就需要扩容
    private void resize(){
          T [] old = table;
          table = (T [])  new Comparable[old.length*2 + 1];//把原来的数组扩大两倍
          for( int i = 0; i < old.length; i++ )
              table[ i ] = old[ i ];        //数组进行拷贝
    }


    //打印数组
    private void print(){
    /*  System.out.println();
        for (int i = 1; i <= size; i++) {
            System.out.print(table[i] + " ");
        }
        System.out.println("二叉堆大小:"+size);*/
    }



    //把数据插入到resultTable末端
    private void insertResult(T t){
        resultTable[resultTable.length - size] = t;
    }

    public static void main(String[] args) {
        Integer[] target = new Integer[100000];
        for (int i = 0; i < 100000; i++) {
            target[i] = i;
        }

        new Heap<Integer>(target, true);
        new Heap<Integer>(target, false);

    }

}

//运行结果：
//直接插入的方式耗时：5
//随机插入重新调整的方式耗时：3
//

从试验的结果来看，先随机插入，后调整二叉堆的效率会高很多。当然了，不排除扩容机制占时的影响，至于为什么会如此，我只能告诉你第一种方式的时间复杂度为O（N），而第二种方式的时间复杂度为O（NlogN），所以第二种是优先的。

2、我们比较是新数组存储排序数据还是直接用二叉堆数组存储排序数据。

package com.brickworkers;

public class Heap<T extends Comparable<? super T>> {

    private static final int DEFAULT_CAPACITY = 10; //默认容量

    private T[] table; //用数组存储二叉堆

    private T[] resultTable;//用于存储有序数据（每次删除的数据就放入其中）

    private int size; //表示当前二叉堆中有多少数据

    public Heap(int capactiy){
        this.size = 0;//初始化二叉堆数据量
        table = (T[]) new Comparable[capactiy + 1];//+1是因为我们要空出下标为0的元素不存储
    }

    public Heap() {//显得专业些，你就要定义好构造器
        this(DEFAULT_CAPACITY);
    }


    //实现方式二，直接先插入，然后对数据进行整理成二叉堆
    public Heap( T [ ] array , boolean methodType){
        if(methodType){
            size = 0;
            table = (T[]) new Comparable[DEFAULT_CAPACITY + 1];
            //实现方式一，直接用insert来实现数据放入二叉堆中
            for (T t : array) {
                    insert(t);
            }
        }else{
            size = array.length;
            table = (T[]) new Comparable[ size + 2 ];//存储的数组要略微长
            for (int i = 0; i < array.length; i++) {
                table[ i+1] = array[i];//arr[0]位置不存放数据
            }
            //到这里为止，数据已经全部都放入了table中
            //接下来要做的就是要把这些数据转变成二叉堆
            for(int i = size/2; i > 0; i--){//从倒数第二层开始处理
                dealHeap(i);
            }
        }
         resultTable = (T[]) new Comparable[ size ];//指定存储数组大小    
    }


    //插入
    public void insert(T t){
        //先判断是否需要扩容
        if(size == table.length - 1){
            resize();
        }
        //开始插入
        //定义一个预插入位置下标
        int target = ++size;
        //循环比较父节点进行位置交换
        for(table[ 0 ] = t; t.compareTo(table[target/2]) < 0; target /= 2){
            table[target] = table[target/2];//如果满足条件，那么两者交换，知道找到合适位置（上滤）
        }
        //插入数据
        table[target] = t;
        print();

    }


    //删除最小
    //删除过程中，需要重新调整二叉堆（下滤）
    public void deleteMin(boolean store){
        if(size == 0){
            throw new IllegalAccessError("二叉堆为空");
        }

        if(store){
//          //把删除的元素放入resultTable中
            insertResult(table[1]);

            //删除元素
            table[1] = table[size--];
        }else{
            //把删除的元素放到末尾
            T temp = table[1];

            //删除元素
            table[1] = table[size--];

            table[size + 1] = temp;
        }




        int target  = 1;//从顶部开始重新调整二叉堆

        dealHeap(target);


        print();
    }

    private void dealHeap(int target) {
        int child;//要处理的节点下标
        T tmp = table[ target ];

        for( ; target * 2 <= size; target = child )
        {
            child = target * 2;
            if( child != size &&table[ child + 1 ].compareTo( table[ child ] ) < 0 ){//如果右孩子比左孩子小
                child++;
            }
            if( table[ child ].compareTo( tmp ) < 0 ){
                table[ target ] = table[ child ];
                table[child] = null;
            }
            else{
                 break;
            }
        }
        table[ target ] = tmp;
    }





    //如果插入数据导致达到数组上限，那么就需要扩容
    private void resize(){
          T [] old = table;
          table = (T [])  new Comparable[old.length*2 + 1];//把原来的数组扩大两倍
          for( int i = 0; i < old.length; i++ )
              table[ i ] = old[ i ];        //数组进行拷贝
    }


    //打印数组
    private void print(){
        /*System.out.println();
        for (int i = 1; i < table.length; i++) {
            System.out.print(table[i] + " ");
        }
        System.out.println("二叉堆大小:"+size);*/
    }



    //把数据插入到resultTable末端
    private void insertResult(T t){
        resultTable[resultTable.length - size] = t;
    }

    public static void main(String[] args) {
        Integer[] target = new Integer[100000];
        for (int i = 0; i < 100000; i++) {
            target[i] = i;
        }


        Heap<Integer> heap1 = new Heap<>(target, true);
        long copyArrStartTime = System.currentTimeMillis();
        //循环删除
        for (int i = 0; i < 100000; i++) {
            heap1.deleteMin(true);
        }
        System.out.println("拷贝数组耗时："+(System.currentTimeMillis() - copyArrStartTime));


        Heap<Integer> heap2 = new Heap<>(target, true);
        long ArrStartTime = System.currentTimeMillis();
        //循环删除
        for (int i = 0; i < 100000; i++) {
            heap2.deleteMin(false);
        }
        System.out.println("直接存储耗时："+(System.currentTimeMillis() - ArrStartTime));
    }

}

//输出结果：
//拷贝数组耗时：23
//直接存储耗时：14
//

其实这个效率问题是显而易见的，少一个数组之间的拷贝，当然会显得高效很多。

希望对你有所帮助。

淳安郭富城
关注
专栏目录
堆排序 （包括升序和降序，Arraylist 实现）
长弓smile的博客
09-12 1255
补充上一篇 利用Arraylist实现的堆排序(包含升序和降序)
Java实现全排列
热门推荐
博客
06-05 3万+
全排列是什么问题？直接举例说明 1，2，3的全排列有 1，2，3 1，3，2 2，1，3 2，3，1 3，1，2 3，2，1 共6种，这是一个简单的排列组合问题，算法思路： dfs+回溯 这样的问题很容易想到递归，定义perm（R）是集合R的全排列，ri是R集合中第i个元素，Ri是R集合中去除ri剩下的元素，即R-ri。要求perm（R），即r1，perm（R1） … … ri，perm（...
java数据结构和算法——堆排序
小志的博客
09-08 386
一、堆排序基本介绍 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。 堆是具有以下性质的完全二叉树。每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆。每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。 大顶堆图解如下： 大顶堆特点：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
堆排序-java
m0_63267251的博客
06-02 1326
这次主要讲了堆排序和堆的基本构造，下一期会详细讲述堆的各种基本操作。
Java实现堆排序算法详解及优化
最新发布
qq_40254606的博客
07-14 942
同时，我们探讨了堆排序的优化方法，包括使用更小的辅助空间，以提高其性能。堆排序通过将数组构建成一个最大堆，然后重复地将堆顶元素与末尾元素交换，并缩小堆的范围，重新调整堆结构来实现排序。交换堆顶和末尾元素: 1, 5, 3, 4, 10。交换堆顶和末尾元素: 1, 4, 3, 5, 10。交换堆顶和末尾元素: 1, 3, 4, 5, 10。构建最大堆: 10, 5, 3, 4, 1。调整堆: 5, 4, 3, 1, 10。调整堆: 4, 1, 3, 5, 10。调整堆: 3, 1, 4, 5, 10。
Java实现：堆排序
m0_63211569的博客
04-19 1454
Java实现：堆排序
Java 中的堆排序-Heap Sort
ljmlh1219的博客
11-17 9168
在本教程中，堆排序基于堆数据结构。为了正确理解堆排序，我们将首先深入研究堆及其实现方式。
堆排序-java实现
stoneWang_L的博客
04-10 1800
目录： https://blog.csdn.net/stoneWang_L/article/details/89228145 1）冒泡排序 https://blog.csdn.net/stoneWang_L/article/details/89220461 2）插入排序 https://blog.csdn.net/stoneWang_L/article/details/89221348 ...
堆排序（java实现）
JiaXingNashishua的博客
06-01 1214
一：堆排序基本介绍 1)堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为0(nlogn)，它也是不稳定排序。 2)堆是具有以下性质的完全二叉树:每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆,注意:没有要求结点的左孩子的值和右孩子的值的大小关系。 3)每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆 4)大顶堆举例说明 5)小顶堆举例说明 一般升序采用大顶堆，降序采用小顶堆。 二：堆排序基本思想 基本思想：...
一文读懂堆排序算法：原理、Java实现及性能分析
万猫学社
04-07 1126
堆排序算法是一种选择排序，它的工作原理是将待排序的序列构造成一个大顶堆。这样，整个序列的最大值就是堆顶的根节点。接着，将其与堆数组的末尾元素进行交换，此时末尾就为最大值。然后再将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次大值。如此反复执行，便能得到一个有序序列了。堆排序算法的基本步骤可以概括为：构建初始堆->交换堆顶元素和堆尾元素并断开(从堆结构中移除)->重新调整堆。其关键操作则主要包括插入节点和调整节点。插入节点时，先将节点插入到堆的尾部，然后依次向上调整整个堆的结构。
详解Java常用排序算法-堆排序
08-26
在上面的代码中，我们使用 Java 语言实现了堆排序算法。其中，Heap 类中包括两个函数：heapSort 和 heapify。heapSort 函数接受一个整数数组作为输入，并使用堆排序算法对该数组进行排序。heapify 函数用于对一个...
[Java算法-排序]-堆排序.java
09-07
该资源提供了Java中实现堆排序的全面指南。文档中涵盖了堆排序的基本概念，包括如何对数组进行排序以及如何在Java中实现堆排序。此外，文档还包括一个逐步指南，介绍了如何在Java中实现堆排序，包括详细的代码示例和...
java代码-堆排序-----
07-16
堆排序是一种基于比较的排序算法，它...总的来说，`main.java`文件应包含了一个完整的Java堆排序实现，通过阅读和理解代码，你可以学习到堆排序的基本思想和编程技巧，这对提升你的Java编程能力和算法理解大有裨益。
深入浅出递归思想
brickworkers的博客
04-04 5049
作为一名程序员，算法是不可或缺的。每个人对算法的敏感度不一样，就想每个人对数学的敏感度一样，有些人逻辑能力就是很强。有一说一，博主个人觉得自己的数学学的不咋滴，但是像我这样笨笨的人，我可以多复习，多推演嘛。今天我想写的是关于递归的理解和使用，我会介绍一下递归的规则，然后用简单和比较难的例子进行学习。
java面试算法题（1）
brickworkers的博客
06-28 3293
引言本篇博文中核心介绍的是一些java很精辟的运算符操作，包含一些独特的思维。在面试的过程中，也可能会遇到这些问题。笔者在阿里巴巴的电话面试过程中就遇到这样的一个问题。分享给大家。
java实现排序(2)-冒泡排序
brickworkers的博客
04-24 2852
引言也许冒泡排序，一个刚出大学的的程序员可能写的出来，反而工作了几年的老程序员可能会写不出来，你还写的出来么？在本篇博文中，详细介绍了冒泡排序的概念，同时用数组和双向链表来实现，附带一种通俗的优化方法。笔者目前整理的一些blog针对面试都是超高频出现的。大家可以点击链接：http://blog.csdn.net/u012403290技术点
java面试算法题（2）
brickworkers的博客
06-29 1910
引言本篇博文中核心是对单链表的数据操作，从不同角度分析问题，寻求不同的结果。分享给大家。
java实现排序(6)-快速排序
brickworkers的博客
05-09 1528
快速排序，作为一个编程人员来说，肯定都是接触过的。那么，你还记得怎么去实现么，怎么优化呢？在本篇博文中，会详细介绍快速排序的过程，对于不是唯一的过程（可变或者可选），我们讨论各种优化的方法。
java实现（1）-二叉查找树
brickworkers的博客
04-20 972
引言在这个模块中，主要是用自己的代码来实现一些底层的源码。不像底层源码那样难理解，会用更加通俗的方式让每个人都能看得懂，比如说不会在if中声明变量和赋值，即使if只有一句话也不会省略花括号，不适用移位等等。在本篇博文中，会用自己的方式来实现二叉查找树，同时把它转变为更加通用的泛型。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值