常见的排序算法 java实现

最新推荐文章于 2025-08-10 21:28:09 发布
最新推荐文章于 2025-08-10 21:28:09 发布
阅读量130 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 算法 文章标签： 算法 Java J#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/iteye_14995/article/details/81924728

一、冒泡排序

Java代码
package sort.bubble;  
 
import java.util.Random;  
/** 
* 依次比较相邻的两个数，将小数放在前面，大数放在后面 
* 冒泡排序，具有稳定性 
* 时间复杂度为O（n^2） 
* 不及堆排序，快速排序O（nlogn，底数为2） 
* @author liangge 
* 
*/ 
public class Main {  
    public static void main(String[] args) {  
        Random ran = new Random();  
        int[] sort = new int[10];  
        for(int i = 0 ; i < 10 ; i++){  
            sort[i] = ran.nextInt(50);  
        }  
        System.out.print("排序前的数组为");  
        for(int i : sort){  
            System.out.print(i+" ");  
        }  
        buddleSort(sort);  
        System.out.println();  
        System.out.print("排序后的数组为");  
        for(int i : sort){  
            System.out.print(i+" ");  
        }  
    }  
      
    /** 
     * 冒泡排序 
     * @param sort 
     */ 
    private static void buddleSort(int[] sort){  
        for(int i=1;i<sort.length;i++){  
            for(int j=0;j<sort.length-i;j++){  
                if(sort[j]>sort[j+1]){  
                    int temp = sort[j+1];  
                    sort[j+1] = sort[j];  
                    sort[j] = temp;  
                }  
            }  
        }  
    }  
} 

package sort.bubble;

import java.util.Random;
/**
* 依次比较相邻的两个数，将小数放在前面，大数放在后面
* 冒泡排序，具有稳定性
* 时间复杂度为O（n^2）
* 不及堆排序，快速排序O（nlogn，底数为2）
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for(int i = 0 ; i < 10 ; i++){
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for(int i : sort){
System.out.print(i+" ");
}
buddleSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for(int i : sort){
System.out.print(i+" ");
}
}

/**
* 冒泡排序
* @param sort
*/
private static void buddleSort(int[] sort){
for(int i=1;i<sort.length;i++){
for(int j=0;j<sort.length-i;j++){
if(sort[j]>sort[j+1]){
int temp = sort[j+1];
sort[j+1] = sort[j];
sort[j] = temp;
}
}
}
}
}


二、选择排序

Java代码
package sort.select;  
 
import java.util.Random;  
 
/** 
* 选择排序 
* 每一趟从待排序的数据元素中选出最小（或最大）的一个元素， 
* 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。  
* 选择排序是不稳定的排序方法。 
* @author liangge 
*  
*/ 
public class Main {  
    public static void main(String[] args) {  
        Random ran = new Random();  
        int[] sort = new int[10];  
        for (int i = 0; i < 10; i++) {  
            sort[i] = ran.nextInt(50);  
        }  
        System.out.print("排序前的数组为");  
        for (int i : sort) {  
            System.out.print(i + " ");  
        }  
        selectSort(sort);  
        System.out.println();  
        System.out.print("排序后的数组为");  
        for (int i : sort) {  
            System.out.print(i + " ");  
        }  
    }  
 
    /** 
     * 选择排序 
     * @param sort 
     */ 
    private static void selectSort(int[] sort){  
        for(int i =0;i<sort.length-1;i++){  
            for(int j = i+1;j<sort.length;j++){  
                if(sort[j]<sort[i]){  
                    int temp = sort[j];  
                    sort[j] = sort[i];  
                    sort[i] = temp;  
                }  
            }  
        }  
    }  
} 

package sort.select;

import java.util.Random;

/**
* 选择排序
* 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
* 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
* 选择排序是不稳定的排序方法。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
selectSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
}

/**
* 选择排序
* @param sort
*/
private static void selectSort(int[] sort){
for(int i =0;i<sort.length-1;i++){
for(int j = i+1;j<sort.length;j++){
if(sort[j]<sort[i]){
int temp = sort[j];
sort[j] = sort[i];
sort[i] = temp;
}
}
}
}
}


三、快速排序

Java代码
package sort.quick;  
 
/** 
* 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小， 
* 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。 
* @author liangge 
*  
*/ 
public class Main {  
    public static void main(String[] args) {  
        int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };  
        System.out.print("排序前的数组为：");  
        for (int data : sort) {  
            System.out.print(data + " ");  
        }  
        System.out.println();  
        quickSort(sort, 0, sort.length - 1);  
        System.out.print("排序后的数组为：");  
        for (int data : sort) {  
            System.out.print(data + " ");  
        }  
    }  
 
    /** 
     * 快速排序 
     * @param sort 要排序的数组 
     * @param start 排序的开始座标 
     * @param end 排序的结束座标 
     */ 
    public static void quickSort(int[] sort, int start, int end) {  
        // 设置关键数据key为要排序数组的第一个元素，  
        // 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小  
        int key = sort[start];  
        // 设置数组左边的索引，往右移动判断比key大的数  
        int i = start;  
        // 设置数组右边的索引，往左移动判断比key小的数  
        int j = end;  
        // 如果左边索引比右边索引小，则还有数据没有排序  
        while (i < j) {  
            while (sort[j] > key && j > start) {  
                j--;  
            }  
            while (sort[i] < key && i < end) {  
                i++;  
            }  
            if (i < j) {  
                int temp = sort[i];  
                sort[i] = sort[j];  
                sort[j] = temp;  
            }  
        }  
        // 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，  
        // 即保持了key左边的数比key小，key右边的数比key大  
        if (i > j) {  
            int temp = sort[j];  
            sort[j] = sort[start];  
            sort[start] = temp;  
        }  
        //递归调用  
        if (j > start && j < end) {  
            quickSort(sort, start, j - 1);  
            quickSort(sort, j + 1, end);  
        }  
    }  
} 

package sort.quick;

/**
* 快速排序 通过一趟排序将要排序的数据分割成独立的两部分， 其中一部分的所有数据都比另外一部分的所有数据都要小，
* 然后再按此方法对这两部分数据分别进行快速排序， 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
* @author liangge
*
*/
public class Main {
public static void main(String[] args) {
int[] sort = { 54, 31, 89, 33, 66, 12, 68, 20 };
System.out.print("排序前的数组为：");
for (int data : sort) {
System.out.print(data + " ");
}
System.out.println();
quickSort(sort, 0, sort.length - 1);
System.out.print("排序后的数组为：");
for (int data : sort) {
System.out.print(data + " ");
}
}

/**
* 快速排序
* @param sort 要排序的数组
* @param start 排序的开始座标
* @param end 排序的结束座标
*/
public static void quickSort(int[] sort, int start, int end) {
// 设置关键数据key为要排序数组的第一个元素，
// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
int key = sort[start];
// 设置数组左边的索引，往右移动判断比key大的数
int i = start;
// 设置数组右边的索引，往左移动判断比key小的数
int j = end;
// 如果左边索引比右边索引小，则还有数据没有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，
// 即保持了key左边的数比key小，key右边的数比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//递归调用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
}
}


四、插入排序

Java代码
package sort.insert;  
 
/** 
* 直接插入排序 
* 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据 
* 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。 
*/ 
import java.util.Random;  
 
public class DirectMain {  
    public static void main(String[] args) {  
        Random ran = new Random();  
        int[] sort = new int[10];  
        for (int i = 0; i < 10; i++) {  
            sort[i] = ran.nextInt(50);  
        }  
        System.out.print("排序前的数组为");  
        for (int i : sort) {  
            System.out.print(i + " ");  
        }  
        directInsertSort(sort);  
        System.out.println();  
        System.out.print("排序后的数组为");  
        for (int i : sort) {  
            System.out.print(i + " ");  
        }  
    }  
 
    /** 
     * 直接插入排序 
     *  
     * @param sort 
     */ 
    private static void directInsertSort(int[] sort) {  
        for (int i = 1; i < sort.length; i++) {  
            int index = i - 1;  
            int temp = sort[i];  
            while (index >= 0 && sort[index] > temp) {  
                sort[index + 1] = sort[index];  
                index--;  
            }  
            sort[index + 1] = temp;  
 
        }  
    }  
} 

package sort.insert;

/**
* 直接插入排序
* 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
* 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
*/
import java.util.Random;

public class DirectMain {
public static void main(String[] args) {
Random ran = new Random();
int[] sort = new int[10];
for (int i = 0; i < 10; i++) {
sort[i] = ran.nextInt(50);
}
System.out.print("排序前的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
directInsertSort(sort);
System.out.println();
System.out.print("排序后的数组为");
for (int i : sort) {
System.out.print(i + " ");
}
}

/**
* 直接插入排序
*
* @param sort
*/
private static void directInsertSort(int[] sort) {
for (int i = 1; i < sort.length; i++) {
int index = i - 1;
int temp = sort[i];
while (index >= 0 && sort[index] > temp) {
sort[index + 1] = sort[index];
index--;
}
sort[index + 1] = temp;

}
}
}


五、顺便贴个二分搜索法

Java代码
package search.binary;  
 
public class Main {  
    public static void main(String[] args) {  
        int[] sort = {1,2,3,4,5,6,7,8,9,10};  
        int mask = binarySearch(sort,6);  
        System.out.println(mask);  
          
    }  
      
      
    /** 
     * 二分搜索法，返回座标，不存在返回-1 
     * @param sort 
     * @return 
     */ 
    private static int binarySearch(int[] sort,int data){  
        if(data<sort[0] || data>sort[sort.length-1]){  
            return -1;  
        }  
        int begin = 0;  
        int end = sort.length;  
        int mid = (begin+end)/2;  
        while(begin <= end){  
            mid = (begin+end)/2;  
            if(data > sort[mid]){  
                begin = mid + 1;  
            }else if(data < sort[mid]){  
                end = mid - 1;  
            }else{  
                return mid;  
            }  
        }  
        return -1;  
          
    }  
} 

 

用Java实现常见排序算法详解
m0_66884848的博客
06-13 1210
本文介绍了6种常见排序算法的Java实现，包括冒泡、选择、插入排序等基础算法，以及快速、归并、堆排序等高效算法。对每种算法从基本思想、时间复杂度分析和Java代码实现三个方面进行详细说明，展示了排序算法的核心逻辑和性能特点。这些排序方法在计算机科学中具有广泛应用，理解其原理和实现有助于提升编程能力和算法思维。
常见排序算法及其java实现
@chen
05-14 1304
java,排序算法
十大经典排序算法的Java实现
m0_63570394的博客
10-30 1974
它也是基于分治策略，但与归并排序不同，快速排序的核心在于分区（partitioning），快速排序占用的空间相对较低，在特点情况下的速度高于归并排序，有很多人说Java底层采用的是快速排序，这种说法有点浅显了，Java底层的排序会根据具体场景选择最优的排序算法。大顶堆保证的是根节点的数值最大，并不能保证叶子节点是有序的，它不是二叉搜索树，所以我们通过构建大顶堆，并不断地取出堆顶的数并放到数组尾部、不断地维护大顶堆，就可以实现升序排序了。时间复杂度为n+k，其中k为待排序数组中最大的数。
Java实现十大经典排序算法详解
weixin_43063624的博客
03-21 2015
排序算法平均时间复杂度最好情况最坏情况空间复杂度稳定性冒泡排序O(n²)O(n)O(n²)O(1)稳定选择排序O(n²)O(n²)O(n²)O(1)不稳定插入排序O(n²)O(n)O(n²)O(1)稳定希尔排序O(n log n)O(n log²n)O(n²)O(1)不稳定归并排序O(n log n)O(n log n)O(n log n)O(n)稳定快速排序O(n log n)O(n log n)O(n²)O(log n)
Java实现十大排序算法
galaxyou的博客
03-19 2019
十大排序算法：插入、冒泡、选择、快速、归并、堆、基数、希尔、计数、桶、
十大经典排序算法（Java实现）
qq_43794633的博客
12-04 3万+
为了加深对这十种算法的理解，固写此文。首先可用如下表来简单概括这十种算法： 目录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排序算法
热门推荐
zzzgd_666的博客
02-18 10万+
1.插入排序 public class InsertSort { public static void sort(int[] arr) { if (arr.length &amp;amp;amp;gt;= 2) { for (int i = 1; i &amp;amp;amp;lt; arr.length; i++) { //挖出一个要用来插入的值,同时位置上留下...
Java常见排序算法-插入排序
super_mochi1
10-15 639
插入排序是一种简单且常用的排序算法，它的实现思路是将列表分为已排序和未排序两部分，每次从未排序部分取出一个元素，将它插入到已排序部分的适当位置，最终将列表排序完成。即将未排序的数值直接插入有序的一组数中，使得插入后的这组数还是有序的。
十大排序算法（Java实现）
ji_meng的博客
06-27 4391
1.冒泡排序 2.快速排序
常见排序算法的实现（Java）
ikun10001的博客
03-05 1169
基数排序是一种稳定的排序算法，时间复杂度为O(d * (n + r))，其中d是最大数的位数，n是待排序数组的长度，r是桶的数量（在基数排序中通常为10）。堆排序是不稳定的排序算法。在待排序序列中找到最小（或最大）的元素，将其放到已排序序列的末尾，然后再从剩余未排序的元素中找到最小（或最大）的元素，放到已排序序列的末尾，重复此过程，直到所有元素都排序完毕。选择一个枢轴元素，将待排序序列分成两个子序列，一个子序列的元素都比枢轴元素小，另一个子序列的元素都比枢轴元素大，然后对两个子序列分别进行快速排序。
几种常见排序算法JAVA实现.pdf
07-14
几种常见排序算法JAVA实现.pdf
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
各种排序算法java实现的源代码.zip
12-23
在“各种排序算法java实现的源代码.zip”这个压缩包中，我们可以预期包含了一系列常见的排序算法的Java实现。例如，该压缩包可能会包含以下几种排序算法的源代码： 1. 冒泡排序（Bubble Sort）：一种简单的排序算法...
java实现数据结构常见排序算法及详解
11-08
### Java 实现数据结构常见排序算法及详解 #### 排序算法概述 排序算法是计算机科学中的基础概念之一，主要用于将一系列数据按照特定规则进行排列。根据数据处理方式的不同，排序算法大致分为两大类：比较排序与非...
机械学习--DBSCAN 算法（附实战案例）
最新发布
enlybbq的博客
08-10 1198
聚类效果：DBSCAN 成功将啤酒分为 3 个有意义的簇（常规啤酒、轻量啤酒、高端啤酒），并识别出 4 种特征异常的啤酒（噪声点），符合实际产品分类逻辑。参数影响：ε=0.6 和 MinPts=5 的组合效果较好，若 ε 增大，可能将噪声点划入簇；若 MinPts 增大，可能导致簇分裂为更多小簇。应用价值：该结果可辅助啤酒企业定位产品市场、优化产品线，或为消费者提供基于特征的选购参考。
NOIP普及组|2001T1数的计算
程序员莫小特的编程世界
08-09 1971
2001年NOIP普及组第1题：数的计算 给出正整数 $n$，要求按如下方式构造数列： 1、只有一个数 $n$ 的数列是一个合法的数列。 2、在一个合法的数列的末尾加入一个正整数，但是这个正整数不能超过该数列最后一项的一半，可以得到一个新的合法数列。
分治-快排-215.数组中的第k个最大元素-力扣(LeetCode)
black_bear_white的博客
08-08 321
深入理解强化学习：近端策略优化（PPO）算法详解
Galen_xia的博客
08-09 943
摘要：近端策略优化（PPO）算法详解 PPO算法是强化学习领域的重要突破，解决了传统策略梯度方法在更新步长敏感性和数据利用率上的局限。基于马尔可夫决策过程框架，PPO通过引入裁剪机制和优势函数估计，在保持训练稳定性的同时简化了计算。核心公式L^CLIP(θ)采用概率比率裁剪技术，将策略更新幅度限制在[1-ε,1+ε]范围内，有效平衡了探索与利用。PPO结合广义优势估计(GAE)和熵正则化项，既保证了性能又提高了采样效率，成为解决复杂决策任务的优选算法。其简洁实现和优异表现使其在学术界和工业界广受青睐。
CF2123A Blackboard Game
zqystca的博客
08-09 358
在样例二中，如果 Alice 选择了 0，那么 Bob 可以选择 3。然后如果 Alice 选择了 2，那么 Bob 可以选择 1。最终 Alice 无数可选，所以 Bob 赢了。游戏在其中一人无法操作时结束，最终无法操作的人输了。在样例一中，如果 Alice 选择了 0，那么 Bob 无法选择任何数，Alice 获胜。每组测试数据仅包含一行一个整数 n（1≤n≤100）表示黑板上写的数字个数。第一行，一个整数 t（1≤t≤100）表示测试数据组数。对于每组测试数据，如果 Alice 必胜，输出。
常见排序算法java实现
07-12
常见的排序算法有许多种，以下是一些常见的排序算法的Java实现示例： 1. 冒泡排序（Bubble Sort）： ```java public void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { // 交换arr[j]和arr[j+1] int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } ``` 2. 插入排序（Insertion Sort）： ```java public void insertionSort(int[] arr) { int n = arr.length; for (int i = 1; i < n; ++i) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j = j - 1; } arr[j + 1] = key; } } ``` 3. 选择排序（Selection Sort）： ```java public void selectionSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { int minIndex = i; for (int j = i+1; j < n; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } // 交换arr[i]和arr[minIndex] int temp = arr[minIndex]; arr[minIndex] = arr[i]; arr[i] = temp; } } ``` 4. 快速排序（Quick Sort）： ```java public void quickSort(int[] arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } } private int partition(int[] arr, int low, int high) { int pivot = arr[high]; int i = (low - 1); for (int j = low; j <= high - 1; j++) { if (arr[j] < pivot) { i++; // 交换arr[i]和arr[j] int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 交换arr[i+1]和arr[high] int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return i + 1; } ``` 这些只是一些常见的排序算法的示例，还有其他排序算法，如归并排序、堆排序等。你可以根据需要选择适合的排序算法进行实现。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值