内部排序比较（Java版）

内部排序比较（Java版）

2017-06-21

目录

1 三种基本排序算法
1.1 插入排序
1.2 交换排序（冒泡）
1.3 选择排序（简单）
2 比较
3 补充
3.1 快速排序
3.2 什么是桶排序
3.3 堆排序

 

1 三种基本排序算法

---

 返回

1.1 插入排序

    public static void InsertSort(int[] arrs) {
        int j;
        int tmp;
        for (int i = 1; i < arrs.length; i++) {
            tmp = arrs[i];
            for (j = i - 1; j >= 0 && tmp < arrs[j]; j--) {
                arrs[j + 1] = arrs[j];
            }
            arrs[j + 1] = tmp;
        }
    }

1.2 交换排序（冒泡）

    public static void BubbleSortS(int[] arrs) {
        int tmp;
        for (int i = arrs.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arrs[j] > arrs[j + 1]) {
                    tmp = arrs[j];
                    arrs[j] = arrs[j + 1];
                    arrs[j + 1] = tmp;
                }
            }
        }
    }

1.3 选择排序（简单）

    public static void SelectSort(int[] arrs) {
        int minIndex;
        int tmp;
        for (int i = 0; i < arrs.length - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < arrs.length; j++) {
                if (arrs[minIndex] > arrs[j])
                    minIndex = j;
            }

            if (minIndex != i) {
                tmp = arrs[minIndex];
                arrs[minIndex] = arrs[i];
                arrs[i] = tmp;
            }
        }
    }

2 比较

---

 返回

 

排序方法	复杂度	辅助空间	内外循环	一次内循环取最大数	一次循环交换次数
插入排序	O(n2)	1	i=1->length-1      j=i-1->0	否	O(1)
冒泡排序	O(n2)	1	i=length-1->1      j=0->i-1	是	O(n)
选择排序	O(n2)	2	i=0->length-1      j=i+1->length-1	是	O(1)

 内部排序（C#）

3 补充

---

 返回

3.1 快速排序

快速排序是对冒泡排序的一种改进。

• 时间复杂度，最坏是O（n2），一般O（nlogn），
• 空间复杂度（递归实现），在一般情况下的空间复杂度为O（logn），在最差的情况下，若每次只完成了一个元素，那么空间复杂度为O（n）

/**
 * 快速排序是在冒泡排序的基础上改进而来的，冒泡排序每次只能交换相邻的两个元素，而快速排序是跳跃式的交换，交换的距离很大，因此总的比较和交换次数少了很多，速度也快了不少。
 * 时间复杂度，最坏是O（n2），一般O（nlogn）
 */
public class QuickSort
{
    public static void main(String[] args)
    {
        int[] arr=new int[]{1,5,2,3,6,8,4,9,7,5};
        QuickSort quickSort=new QuickSort(arr);
        quickSort.sort();
        quickSort.print();
    }

    private int[] arr;
    public QuickSort(int[] arr)
    {
        this.arr=arr;
    }

    public void sort()
    {
        quickSort(arr,0,arr.length-1);
    }

    public void quickSort(int[] arr,int begin,int end)
    {
        if(begin<end)
        {
            int i = partition(arr, begin, end);
            quickSort(arr,begin,i-1);
            quickSort(arr,i+1,end);
        }
    }

    private int partition(int[] arr, int begin, int end) {
        int key=arr[begin];
        while(begin<end)
        {
            while (begin<end&&arr[end]>=key)end--;
            if(begin<end) {
                arr[begin] = arr[end];
            }
            while(begin<end&&arr[begin]<=key)begin++;
            if(begin<end) {
                arr[end] = arr[begin];
            }
        }
        arr[begin]=key;
        return begin;
    }

    public void print()
    {
        for(int value:arr)
            System.out.println(value);
    }
}

View Code