排序算法Java实现

最新推荐文章于 2023-06-27 14:16:23 发布
最新推荐文章于 2023-06-27 14:16:23 发布
阅读量2.1k 收藏 3
点赞数 2
分类专栏： javaee 文章标签： 排序算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hsx1612727380/article/details/51170514
版权

排序算法Java实现

排序算法的分类：

  • 内部排序，在排序过程中，全部记录放在内存中，称为内部排序；
  • 外部排序，在排序过程中需要使用外部存储（磁盘），则称为外部排序。

主要介绍内部排序：

  • 插入排序：直接插入排序、二分法插入排序、希尔排序
  • 选择排序：简单选择排序、堆排序
  • 交换排序：冒泡排序、快速排序
  • 归并排序
  • 基数排序

插入排序

直接插入排序

  • 基本思想：对于给定的一组记录，初始时假设第一个记录自成一个有序序列，其余记录为无序序列。接着从第二个记录开始，按照记录的大小依次将当前处理的记录插入到其之前的有序序列中，直至最后一个记录插入到有序序列中为止。
  • 程序示例：
package com.hsx;

/**
 * 直接插入排序
 */
public class DirectInsert {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        insertSort(array);
        System.out.println();
        System.out.println("排序之后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }

    /**
     * 直接插入排序算法
     * @param a
     */
    public static int[] insertSort(int[] a) {
        if (a != null) {
            for (int i = 1; i < a.length; i++) {
                // 带插入的元素
                int temp = a[i];
                int j;
                // 从已排序的部分的最后一个元素开始比较
                for (j = i - 1; j >= 0; j--) {
                    // 将大于带插入temp元素向后移
                    if (a[j] > temp) {
                        a[j + 1] = a[j];
                    }
                    else {
                        break;
                    }
                }
                a[j + 1] = temp;
            }
        }
    }

}
  • 分析：
    • 稳定排序。
    • 当文件的初始状态为有序的时候，每个待排序只需要比较一次就能找到合适的位置，则算法的时间复杂度为O(n)；当文件的初始状态为反序的，第i个待插入的元素需要比较i+1次才能找到合适的位置插入，则算法的时间复杂度为O(n2); 直接插入排序的时间复杂度为O(n2)。
    • 辅助空间O(1)。

二分法插入排序

  • 基本思想：在插入第i个元素时，对前面的第0~i-1个元素（已经是排序的）进行折半，先与他们中间的元素比较，如果小，则对前半部分进行折半，否则对后半部分折半，直到left>right，然后把第i个元素的前一位与目标元素位置之间的所有元素后移，再把第i个元素放在目标位置上。
  • 程序示例：
package com.hsx;

/**
 * 二分插入排序
 */
public class BinaryInsert {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        insertSort(array);
        System.out.println();
        System.out.println("排序之后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }

    /**
     * 二分插入排序算法
     * @param a
     */
    public static void insertSort(int[] a) {

        if (a != null) {
            for (int i = 1; i < a.length; i++) {
                // 待插入的元素
                int temp = a[i];
                int right = i - 1;
                int left = 0;
                int mid = 0;
                while (left <= right) {
                    mid = (left + right) / 2;
                    if (temp < a[mid]) {
                        right = mid - 1;
                    }
                    else {
                        left = mid + 1;
                    }
                }
                for (int j = i - 1; j >= left; j--) {
                    a[j + 1] = a[j];
                }
                if (left != i) {
                    a[left] = temp;
                }
            }
        }
    }

}
  • 分析：
    • 稳定排序。
    • 二分插入排序的比较次数与待排序记录的初始状态无关，仅仅依赖于元素的个数。当n较大时，比直接插入排序的最大比较次数少得多，但是大于直接插入排序的最小比较次数。算法的移动次数与直接插入排序算法的相同，最坏的情况为O(n2/2)->O(n2)，最好的情况为O(n)，平均移动次数为O(n2)。

希尔排序

  • 基本思想：先取一个小于n的整数d1作为第一个增量，把文件的全部元素分组。所有距离为d1的倍数的元素放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2
package com.hsx;

/**
 * 希尔排序
 */
public class ShellInsert {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        insertSort(array);
        System.out.println();
        System.out.println("排序之后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }

    /**
     * 希尔排序算法
     * @param a
     */
    public static void insertSort(int[] a) {

        int d = a.length;
        while (true) {
            d = d / 2;
            for (int i = 0; i < d; i++) {
                for (int j = i + d; j < a.length; j = j + d) {
                    int temp = a[j];
                    int k;
                    for (k = j - d; k >= 0 && a[k] > temp; k = k - d) {
                        a[k + d] = a[k];
                    }
                    a[k + d] = temp;
                }
            }
            if (d == 1) {
                break;
            }
        }
    }

}
  • 分析：
    • 不稳定排序
    • 当文件初态基本有序时直接插入排序所需的比较和移动次数均较少；当n值较小时，n和n2的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n2)差别不大；在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快；希尔排序的平均时间复杂度为O(nlogn)。
    • 辅助空间O(1)。

选择排序

简单选择排序

  • 基本思想：设所排序序列的元素个数为n。i取1,2,…,n-1,从所有n-i+1个元素（Ri,Ri+1,…,Rn）中找出排序码最小的元素，与第i个元素交换。执行n-1趟 后就完成了记录序列的排序。
  • 程序示例：
package com.hsx;

/**
 * 简单选择排序
 */
public class SimpleSelect {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
        selectSort(array);
        System.out.println();
        System.out.println("排序之后：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + " ");
        }
    }

    /**
     * 简单选择排序算法
     * @param a
     */
    public static void selectSort(int[] a) {

        if (a != null) {
            for (int i = 0; i < a.length; i++) {
                int min = a[i];
                int n = i; //最小索引数
                for (int j = i + 1; j < a.length; j++) {
                    if(min > a[j]) {
                        min = a[j];
                        n = j;
                    }
                }
                a[n] = a[i];
                a[i] = min;
            }
        }
    }

}
  • 分析：
    • 不稳定排序。
    • 时间复杂度O(n2)，最好、最坏、平均都是O(n2)。
    • 辅助空间O(1)。

堆排序

  • 基本思想：
    • 堆的定义：具有n个元素的序列 （h1,h2,…,hn),当且仅当满足（hi>=h2i,hi>=h2i+1）或（hi<=h2i,hi<=h2i+1） (i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二 叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
    • 思想：初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
  • 程序示例：
package com.hsx;

import java.util.Arrays;

/**
 * 堆排序
 */
public class HeapSelect {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        System.out.println(Arrays.toString(array));
        selectSort(array);
        System.out.println("排序之后：");
        System.out.println(Arrays.toString(array));
    }

    /**
     * 堆排序
     * @param a
     */
    public static void selectSort(int[] a) {

        if (a != null) {
            // 循环建堆
            int length = a.length;
            for (int i = 0; i < length - 1; i++) {
                //建堆
                buildMaxHeap(a, length - 1 - i);
                //交换
                swap(a, 0, length - 1 - i);
            }
        }
    }

    /**
     * 建堆:建大顶堆
     * @param a
     * @param lastIndex
     */
    public static void buildMaxHeap(int[] a, int lastIndex) {

        // 从lastIndex出节点(最后一个节点)的父节点开始
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
            // k保存正在判断的的节点
            int k = i;
            // 如果当前k节点的字节点存在
            while (k * 2 + 1 <= lastIndex) {
                // k节点的左节点的索引
                int biggerIndex = 2 * k + 1;
                // 如果biggerIndex小与lastIndex，即biggerIndex代表的右节点存在
                if (biggerIndex < lastIndex) {
                    // 如果右及诶单的值较大
                    if (a[biggerIndex] < a[biggerIndex + 1]) {
                        // biggerIndex总是记录较大子节点的索引
                        biggerIndex++;
                    }
                }
                // 如果k节点的值小于其较大的子节点的值
                if (a[k] < a[biggerIndex]) {
                    // 交换
                    swap(a, k, biggerIndex);
                    // 将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右节点的值
                    k = biggerIndex;
                }
                else {
                    break;
                }
            }
        }
    }

    /**
     * 交换
     * @param a
     * @param j
     */
    public static void swap(int[] a, int i, int j) {
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}
  • 分析：
    • 不稳定排序。
    • 时间复杂度O(nlog2n)，最好、最坏、平均都是O(nlog2n)。
    • 辅助空间O(1)。
    • 建堆过程中比较的次数较多，堆不适合用于多数据元素的比较。

交换排序

冒泡排序

  • 基本思想：
    1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
    2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
    3. 针对所有的元素重复以上的步骤，除了最后一个。
    4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
  • 程序示例：
package com.hsx;

import java.util.Arrays;

/**
 * 冒泡排序
 */
public class BubbleSort {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        System.out.println(Arrays.toString(array));
        swapSort(array);
        System.out.println("排序之后：");
        System.out.println(Arrays.toString(array));

    }

    /**
     * 冒泡排序算法
     * @param a
     */
    public static void swapSort(int[] a) {

        if (a != null) {
            // 比较多少次
            for (int i = 0; i < a.length; i++) {
                // 每两个元素之间进行比较
                for (int j = 0; j < a.length - i - 1; j++) {
                    if (a[j] > a[j + 1]) {
                        int temp = a[j];
                        a[j] = a[j + 1];
                        a[j + 1] = temp;
                    }
                }
            }
        }
    }

}
  • 分析：
    • 稳定排序。
    • 最好的情况下，文本中元素已经是排序好的，这时的时间复杂度是O(n)，最坏的情况下，文本中元素是反序的，这时的时间复杂度是O(n2)，平均时间复杂度是O(n2)。
    • 空间复杂度O(1)[辅助空间]

快速排序

  • 基本思想：设要排序的数组是A[0]……A[n-1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。
    • 一趟快速排序的算法是：
      1. 设置两个变量i、j，排序开始的时候：i=0，j=n-1；
      2. 以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
      3. 从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
      4. 从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
      5. 重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
  • 程序示例：
package com.hsx;

import java.util.Arrays;

/**
 * 快速排序
 */
public class QuickSort {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        System.out.println(Arrays.toString(array));
        swapSort(array);
        System.out.println("排序之后：");
        System.out.println(Arrays.toString(array));
    }

    /**
     * 快速排序算法
     * @param a
     */
    public static void swapSort(int[] a) {

        if (a != null) {
            quickSort(a, 0, a.length - 1);
        }

    }

    /**
     * 递归调用
     * @param a
     * @param low
     * @param high
     */
    public static void quickSort(int[] a, int low, int high) {

        if (low < high) {
            int mid = getMid(a, low, high);
            quickSort(a, low, mid - 1);
            quickSort(a, mid + 1, high);
        }
    }

    public static int getMid(int[] a, int low, int high) {
        int key = a[low];
        while (low < high) {
            // 找到比关键字小的元素位置
            while (low < high && a[high] >= key) {
                high--;
            }
            a[low] = a[high];
            while (low < high && a[low] <= key) {
                low++;
            }
            a[high] = a[low];
        }
        a[low] = key;
        return low;
    }

}
  • 分析：
    • 不稳定排序。
    • 最坏的情况下，每次区间的划分的结果都是关键字的左边(或右边)序列为空，而另一边区间中的元素仅比排序前少了一项，即选择的关键字是待排序中的所有元素中的最小或者最大的，这时的时间复杂度是O(n2)；最好的情况下，每次区间的划分的结果都是关键字左右两边的元素的长度相等或者相差为1，即选择的关键字为待排序的元素中的中间值，此时的时间复杂度为O(nlog2n)；快速排序的平均时间复杂度是O(nlog2n)。
    • 空间复杂度是O(nlog2n)

归并排序

  • 基本思想：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
    • 归并过程： 比较a[i]和a[j]的大小，若a[i]≤a[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素a[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。归并排序的算法我们通常用递归实现，先把待排序区间[s,t]以中点二分，接着把左边子区间排序，再把右边子区间排序，最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。
    • 归并原理：
      1. 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
      2. 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
      3. 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
      4. 重复步骤3直到某一指针超出序列尾，将另一序列剩下的所有元素直接复制到合并序列尾。
  • 程序示例：
package com.hsx;

import java.util.Arrays;

/**
 * 归并排序
 */
public class MergerSort {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        System.out.println(Arrays.toString(array));
        mergerSort(array, 0, array.length - 1);
        System.out.println("排序之后：");
        System.out.println(Arrays.toString(array));
    }

    /**
     * 归并排序算法
     * @param a
     */
    public static void mergerSort(int[] a, int left, int right) {

        if (a != null) {
            if (left < right) {
                int mid = (left + right) / 2;
                mergerSort(a, left, mid);
                mergerSort(a, mid + 1, right);
                merger(a, left, mid, right);
            }
        }
    }

    public static void merger(int[] a, int left, int mid, int right) {

        int[] tempA = new int[a.length];
        int middle = mid + 1;
        int temp = left;
        int third = left;
        while (left <= mid && middle <= right) {
            // 从两个数字中选取较小的元素放入到中间数组
            if (a[left] <= a[middle]) {
                tempA[third++] = a[left++];
            }
            else {
                tempA[third++] = a[middle++];
            }
        }
        // 将剩余的部分放入到中间数组
        while (left <= mid) {
            tempA[third++] = a[left++];
        }
        while (middle <= right) {
            tempA[third++] = a[middle++];
        }
        // 将中间数组复制到原数组
        while (temp <= right) {
            a[temp] = tempA[temp++];
        }

    }

}
  • 分析：
    • 稳定排序。
    • 最好、最坏、平均时间复杂度都是O(nlog2n).
    • 空间复杂度是O(1)。

基数排序

  • 基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
  • 程序示例：
package com.hsx;

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

/**
 * 基数排序(桶排序)
 */
public class BucketSort {

    public static void main(String[] args) {

        int[] array = {38,65,97,76,13,27,49};
        System.out.println("排序之前：");
        System.out.println(Arrays.toString(array));
        bucketSort(array);
        System.out.println("排序之后：");
        System.out.println(Arrays.toString(array));

    }

    /**
     * 基数排序算法
     * @param a
     */
    public static void bucketSort(int[] a) {
        //找到最大数，确定要排序几趟
        int max = 0;
        for (int i = 0; i < a.length; i++) {
            if(max<a[i]){
                max = a[i];
            }
        }
        //判断位数
        int times = 0;
        while(max>0){
            max = max/10;
            times++;
        }
        //建立十个队列
        List<ArrayList> queue = new ArrayList<ArrayList>();
        for (int i = 0; i < 10; i++) {
            ArrayList queue1 = new ArrayList();
            queue.add(queue1);
        }
        //进行times次分配和收集
        for (int i = 0; i < times; i++) {
            //分配
            for (int j = 0; j < a.length; j++) {
                int x = a[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
                ArrayList queue2 = queue.get(x);
                queue2.add(a[j]);
                queue.set(x,queue2);
            }
            //收集
            int count = 0;
            for (int j = 0; j < 10; j++) {
                while(queue.get(j).size()>0){
                    ArrayList<Integer> queue3 = queue.get(j);
                    a[count] = queue3.get(0);
                    queue3.remove(0);
                    count++;
                }
            }
        }
    }

}
  • 分析：
    • 稳定排序。
    • 分配需要O(n),收集为O(r),其中r为分配后链表的个数，以r=10为例，则有0～9这样10个链表来将原来的序列分类。而d，也就是位数(如最大的数是1234，位数是4，则d=4)，即”分配-收集”的趟数。因此时间复杂度为O(d*(n+r))。
    • 适用情况：如果有一个序列，知道数的范围(比如1～1000)，用快速排序或者堆排序，需要O(N*logN)，但是如果采用基数排序，则可以达到O(4*(n+10))=O(n)的时间复杂度。算是这种情况下排序最快的。
    • 空间复杂度O(rd+n)。
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
各种排序算法java实现
03-18
标题 "各种排序算法java实现" 涉及到的是计算机科学中的一个重要领域——算法，特别是排序算法在Java编程语言中的具体应用。排序算法是数据结构与算法分析中的基础部分，它们用于将一组数据按照特定顺序排列。在这个...
插入排序（直接插入、二分插入、希尔排序）
atwdy的博客
07-28 229
直接插入 描述： 从原始序列第二个元素起，依次选取并插入到前面合适的位置，直到序列最后一个元素完成插入。 java代码 public void insertSort(int[] arr) { int temp, j; for (int i = 1; i < arr.length; i++) { // 从第二个元素起 temp = arr[i]; // 取出待排元素 // 待排元素与它前面的元素从后往前比较，根据比较结果判断前面元素是否后移 for (j = i;
java实现10种排序算法
热门推荐
weixin_622464的博客
05-06 7万+
1.冒泡排序(Bubble Sort) import java.util.Arrays; //冒泡排序 public class BubbleSort_01 { public static void main(String[] args) { int a[]={3,44,38,5,47,15,36,26,27,2,46,4,19,50,48}; //记录比较次数 int count=0; //i=0,第一轮比较 for (int i = 0; i < a.length-1; i
十大经典排序算法（Java实现）
qq_43794633的博客
12-04 2万+
为了加深对这十种算法的理解，固写此文。首先可用如下表来简单概括这十种算法： 目录1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序9、桶排序10、基数排序 十大经典排序算法 平均时间复杂度 最好时间复杂度 最坏时间复杂度 空间复杂度 排序方式 稳定性 冒泡排序 O\OmicronO(n2) O\OmicronO(n) O\OmicronO(n2) O\OmicronO(1) In-place 稳定 选择排序 O\OmicronO(n2) O\O
冒泡排序算法-java实现
qq_19942717的博客
07-31 1487
冒泡排序（BubbleSort）是一种最基础的交换排序排序思想相邻元素做比较，决定是否交换位置原始的冒泡排序是稳定排序，时间复杂度是O(N^2)
十大排序算法（Java实现）
ji_meng的博客
06-27 3933
1.冒泡排序 2.快速排序
java实现七种经典排序算法
诸葛浪
07-29 4047
七种常见排序算法java代码及图示，所有代码均可单独独立运行
归并排序算法（java实现）
qq_45954420的博客
03-10 1万+
基本思想 归并排序是由递归实现的，主要是分而治之的思想，也就是通过将问题分解成多个容易求解的局部性小问题来解开原本的问题的技巧。 归并排序在合并两个已排序数组时，如果遇到了相同的元素，只要保证前半部分数组优先于后半部分数组， 相同元素的顺序就不会颠倒。所以归并排序属于稳定的排序算法。 每次分别排左半边和右半边，不断递归调用自己，直到只有一个元素递归结束，开始回溯，调用 merge 函数，合并两个有序序列，再合并的时候每次给末尾追上一个最大 int 这样就不怕最后一位的数字不会被排序。 归并排序的效率
快速排序算法（java实现）
qq_45954420的博客
03-11 1万+
基本思想 快速排序是一种采用分治法解决问题的一个典型应用，也是冒泡排序的一种改进。它的基本思想是，通过一轮排序将待排记录分割成独立的两部分，其中一部分均比另一部分小，则可分别对这两部分继续进行排序，已达到整个序列有序。排序的时间复杂度为 O(nlogn)，相比于简单排序算法，运算效率大大提高。 算法步骤 从序列中取出一个数作为中轴数； 将比这个数大的数放到它的右边，小于或等于他的数放到它的左边； 再对左右区间重复第二步，直到各区间只有一个数。 例如，对以下 10..
快速排序算法（JAVA实现）
qq_56627079的博客
11-30 3504
快速排序算法
排序算法之希尔排序(Java实现)
weixin_58699220的博客
06-21 1206
希尔排序
三种线性排序算法Java实现
08-07
本资源提供的Java实现包括了三种线性排序算法：桶排序（Bucket Sort）、基数排序（Radix Sort）和计数排序（Counting Sort）。这三种算法在特定条件下可以达到线性的平均或最好时间复杂度，效率相对较高。 1. **桶...
Kindeditor-4.1.10使用
hsx1612727380的专栏
05-19 4680
Kindeditor-4.1.10使用kindeditor-4.1.10下载地址kindeditor-4.1.10kindeditor-4.1.10在JavaWeb工程中使用kindeditor-4.1.10放到自己工程的目录下，一般位于WebRoot目录下面。开始kindeditor-4.1.10放入WebRoot中时，kindeditor-4.1.10文件下的有些文件时报错的，但是我们不能修改其
XML简单介绍
hsx1612727380的专栏
04-14 3649
XML编程主要内容： XML及其语法 XML约束之DTD XML编程（CRUD - Create Read Update Delete） XML约束之Schema XML概述什么是XML XML是指可扩展标记语言(eXtensible Markup Language),他是一种标记语言，很类似HTML，他被设计的宗旨是传输数据，而非显示数据。 XML标签没有被预定义，需要用户自行定义标签。 XML技
JDBC介绍
hsx1612727380的专栏
05-02 3253
JDBCSUN公司为了简化。统一对数据库的操作，定义一套Java操作数据库的规范，称之为JDBC。JDBC简介JDBC（Java DataBase Connectivity）Java数据库连接，主要有接口组成。组成JDBC的2个包： java.sql javax.sql 开发JDBC应用需要以上2个包支持外，还需要导入相应的JDBC的数据库实现，即数据库驱动。编写JDBC程序步骤 搭建实验环境：
JavaWeb开发中的会话技术[Cookie/Session]
hsx1612727380的专栏
04-20 1650
会话会话：用户打开一个浏览器，点击多个超链接，访问服务器多个web资源，然后关闭浏览器，整个过程称之为一个会话。会话过程中要解决的一些问题： 每个用户在使用浏览器与服务器进行会话的过程中，不可避免各自回产生一些数据，程序要想办法为每个用户保存这些资源。电商中的保存用户的购买的商品。 保存会话数据的两种技术 Cookie：Cookie是客户端技术，程序把每个用户的数据以cookie的形式写给用户各自的
使用mybatis的逆向工程(xml方式)创建java代码
hsx1612727380的专栏
06-20 1207
1.  xml配置文件 generatorConfig.xml <!DOCTYPE generatorConfiguration PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN" "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd"
常见排序算法java实现
最新发布
07-12
常见的排序算法有许多种，以下是一些常见的排序算法的Java实现示例： 1. 冒泡排序（Bubble Sort）： ```java public void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i ; i++) { for (int j ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

鬼王呵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值