java排序，效率高的是哪种排序方法

Posted 2023-05-07

java排序，效率高的是哪种排序方法

和所有其他语言是一样的。应该还是快速排序效率最高。

public static void bubbleSort(int a[])
int len = a.length;
for (int i = 0; i < len - 1; i++)
for (int j = 0; j < len - 1 - i; j++)
if (a[j] > a[j + 1])
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;




public static void selectSort(int a[])
int temp = 0;
int len = a.length;
for (int i = 0; i < len - 1; i++)
int min = a[i];
int index = i;
for (int j = i + 1; j < len; j++)
if (min > a[j])
min = a[j];
index = j;


temp = a[i];
a[i] = a[index];
a[index] = temp;


public static void insertSort(int a[])
int len = a.length;
for (int i = 1; i < len; i++)
int temp = a[i];// 待插入的值
int index = i;// 待插入的位置
while (index > 0 && a[index - 1] > temp)
a[index] = a[index - 1];// 待插入的位置重新赋更大的值
index--;// 位置往前移

a[index] = temp;


public static int partition(int a[], int low, int height)
int key = a[low];
while (low < height)
while (low < height && a[height] >= key)
height--;
a[low] = a[height];
while (low < height && a[low] <= key)
low++;
a[height] = a[low];

a[low] = key;
return low;

public static void quickSort(int a[], int low, int height)
if (low < height)
int result = partition(a, low, height);
quickSort(a, low, result - 1);
quickSort(a, result + 1, height);


测试结果
------------------------------------------
测试数据10000
冒泡排序：120ms
选择排序：32ms
插入排序：20ms
快速排序：7ms
------------------------------------------
测试数据100000
冒泡排序：13098ms
选择排序：2334ms
插入排序：1264ms
快速排序：23ms
效率差距很大啊！！！！ 参考技术A 具体情况具体分析。。。
数据基本有序了用冒泡最快了
归并排序占用空间
适用于对空间要求不高的场合
堆排序情况也跟归并差不多
但也与堆的实现有关系
快速排序一般来说很好，适用于数据量大的情况
数据量少的话还是别用了
有时反而不如O(n^2)的排序方法 参考技术B 看具体情况使用.顺序排列,索引最快是LinkedList,有插入操作的是ArrayList
Verctor是同步的,安全,性能较低 参考技术C 你百度一下快速排序。它是左右两边同时排序的，效率很高。 参考技术D 和所有其他语言是一样的。应该还是快速排序效率最高。本回答被提问者采纳

Java 常用排序

Java 常用排序，习惯规则的使用“从小到小”后者从“从大到小”进行数组的相关排序！为了方面应用直接采取工具类的方式来抽取相关方法。
以下列出常用的排序方式：
需要补充说明的是：排序是一种算法，希尔排序是排序最快的，运算最快的，效率最高的！

public class SortOperation 

    /**
     * 选择排序
     * 拿到数组的第0个元素，依次为之后的元素进行对比
     * 第一次排序结束之后，拿数组的第1个元素依次对比（第0个元素除外）
     * @param data
     */
    public void selectSort(int[] data) 

        for (int i = 0; i < data.length - 1; i++) 
            for (int j = i + 1; j < data.length; j++) 
                if (data[i] > data[j]) 
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                
            
        

        System.out.println("选择排序的结果值：");
        for (int i = 0; i < data.length; i++) 
            System.out.print(data[i] + "、");
        
    



 /**
     * 冒泡排序
     *
     * @param data
     */
    public void bubbleSort(int[] data) 

        for (int i = 0; i < data.length - 1; i++) 

            for (int j = 0; j < data.length - i - 1; j++) 
                if (data[j] > data[j + 1]) 
                    int temp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = temp;


                
            
        
        System.out.println("冒泡排序的结果值：");
        for (int i = 0; i < data.length; i++) 
            System.out.print(data[i] + "、");
        
    

  /**
     * 折半查找法
     *
     * @param key
     * @param data
     */
    public static int biSearch(int key, int[] data) 

        int start = 0;
        int end = data.length - 1;

        int center = (start + end) >> 1;  //  ">>1" 代表 "/2"

        while (data[center]!= key) 
            if (key > data[center]) 
                start = center + 1;
             else if (key < data[center]) 
                end = center - 1;
            
            if (start > end)    // key 大于 数组中的任何一个 元素的时候，使用 -1 来标示
                return -1;
            

            center = (start + end) >> 1;
        
        return center;
    



/**
 *测试类
 */
public class MyClass 
    private static int []data = 5, 3, 4, 1, 0, 2, 12,;
    private static int b[] = 1, 3, 4, 45, 50, 52, 62,;
    public static void main(String args[]) 
        SortOperation operation = new SortOperation();

//        operation.selectSort(data);
        operation.bubbleSort(data);
         int index = operation.biSearch(320,b);
        System.out.println("下标："+index);