八大基本排序

Posted ddiamondd

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了八大基本排序相关的知识,希望对你有一定的参考价值。

技术图片

内部排序:在排序期间数据对象全部存放在内存的排序

外部排序:指在排序期间对象太多,不能同时存放在内存中,必须根据排序过程的要求,不断在内、外存间移动。

效率的衡量:

  内部排序:比较的次数(即时间复杂度)

  外部排序:IO次数

性能比较:

技术图片

稳定:待排序序列中相同数字的顺序 在 排好序后,顺序不发生改变。

技术图片

直接插入排序:

/**
 * 直接插入排序
 * 思想: 将待排元素 与 已经排好序的元素进行比较
 * 升序:(逆序比较)若待排元素 小于 已排元素,则交换位置; 若待排元素 大于 已排元素,则不交换,停止比较。
 */
public class InsertSort 
    public static void main(String[] args)
        int[] arr = new int[]12, 3, 9, 24, 45, 17;
        for(int i = 1; i < arr.length; i++) //待比较元素的小标 从第二个元素开始
            // 如果j是 从0~(i-1) 那么比较会涉及到元素后移,增加时间复杂度
                    for(int j = i-1; j >= 0; j--)
                        if(arr[i] < arr[j])   // 直接插入排序稳定 如果是arr[i] <= arr[j] 则不稳定
                            int temp = arr[i];   
                            arr[i] = arr[j];
                            arr[j] = temp;
                
            
        
        for(int x : arr)
            System.out.print(x + " ");
        
    

最好的情况:待排数组已经排好序, 待排元素只需跟已排元素比较一次   O(n)

最坏情况: 待排数组与预期顺序全部逆序,每个待排元素需要与全部的已排元素比较一次   O(技术图片)

使用场景:规模较小或者基本有序

希尔排序:是插入排序的改进版

public class SheelSort 
    public static void main(String[] args)
        int[] arr = new int[]12, 3, 9, 24, 45, 17, 33, 7, 11, 15;
        for(int gap = arr.length/2; gap >= 1; gap /= 2)
            // 将arr[i]插入到每组 对应的位置
            for(int i = gap; i < arr.length; i++) // i 是每组元素的第二个元素
                int d = arr[i];
                int j;
                // 待排元素是: arr[i], 已排元素是: i-gap, i-2gap.... 逆着比较
                for(j = i-gap; j >= 0 && d < arr[j]; j -= gap)
                    arr[j+gap] = arr[j]; // 若已排元素大于待排元素temp 则往后移动
                
                arr[j+gap] = d;
            
        
        for(int x : arr)
            System.out.print(x + " ");
        
    

技术图片

在进行排序的过程中,并不是对某组排完序后再对另一组排序,而是各组轮流排序。(可以设个断点看看变化)

直接选择排序:

/**
 * 算法思想:进行n-1次循环,在第i(从0开始)次循环中,在待排序列中找到最小(大)值的下标,看是否与i相等,
 * 如果不相等,则两个位置上的元素进行交换
 */
public class SelectSort 
    public static void main(String[] args)
        int[] arr = new int[]12, 3, 9, 24, 45, 17;
        for(int i = 0; i < arr.length-1; i++) // 循环次数
            int min = i;
            for(int j = i+1; j < arr.length; j++) //在待排序列中 找到最小元素的小标
                if(arr[j] < arr[min])
                    min = j;
                
            
            if(min != i) // 如果最小元素不是 arr[i]  则arr[i]与最小元素进行交换
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            
        
        for(int x : arr)
            System.out.print(x + " ");
        
    

堆排序:

冒泡排序:

/**
 * 冒泡排序
 * 算法思想:比较交换
 */
public class BubbleSort 
    public static void main(String[] args)
        int[] arr = new int[]12, 3, 9, 24, 45, 17;
        for(int i = 0; i < arr.length-1; i++)
            boolean flag = false; // 看序列是否已经有序  没有交换就表示序列已经有序
            for(int j = 0; j < arr.length-i-1; j++) //从下标0开始,只需要比较到待排序列的倒数第二个元素即可
                if(arr[j] > arr[j+1])
                    flag = true;
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                
            
            if(flag == false) 
                break;
            
        
        for(int x : arr)
            System.out.print(x + " ");
        
    

最好情况: 待排序列已经有序,就只需要一个循环的比较即可  O(n)

最坏情况: 待排序列与想象中的序列完全逆序  O(技术图片)

快速排序:

/**
 * 算法思想:找一个基准数,把比基准数小的数往左移, 比基准数大的往右移,每一次的排序都会把基准数放在正确位置
 */
public class QuickSort 
    public static void quickSort(int[] arr, int start, int end)
        if(start >= end) return ;
        int point = arr[start];
        int low = start, high = end;
        while(low < high)
            while(low < high && arr[high] >= point)
                high--;
             // 循环结束时, arr[high] < point
            if(low < high)
                arr[low] = arr[high];
                low++;
            
            while(low < high && arr[low] <= point)
                low++;
             // 循环结束时,arr[low] > point
            if(low < high)
                arr[high] = arr[low];
                high--;
            
        
        arr[high] = point;  //把point放在正确的位置上  point左边就是比point小的数 右边就是比point大的数
        quickSort(arr, start, high-1);
        quickSort(arr, high+1, end);
    
    public static void main(String[] args)
        int[] arr = new int[]12, 3, 9, 24, 45, 17;
        quickSort(arr, 0, arr.length-1);
        for(int x : arr)
            System.out.print(x + " ");
        
    

归并排序:

基数排序:

 

以上是关于八大基本排序的主要内容,如果未能解决你的问题,请参考以下文章

八大排序之基本概念简介

八大基本排序--基数排序

Java八大基本排序之堆排序

八大基本排序---堆排序堆结构

八大基本排序---快速排序(荷兰国旗问题)

八大排序:简单选择排序