美文网首页
基础排序算法

基础排序算法

作者: LeoFranz | 来源:发表于2019-08-10 10:18 被阅读0次

  • 插入排序
    从空集合开始,不断把记录插入到合适位置的排序方法
  • 交换排序
    交换元素的位置进行排序

插入排序

直接插入排序
public static void drectlyInsertSort(int[] array){
        for (int i = 1; i < array.length; i++) {
            int temp = array[i];
            int j = 0;
            for (j = i-1; j >= 0 && array[j]>temp; j--) {
                array[j+1] = array[j];;
            }
            array[j+1] = temp;
        }
    }

时间复杂度
最好:已经有序的情况下,只需要遍历数列一次,为O(n)。
最坏:反序情况下比较次数依次是1 + 2 + 3 + ... + (N - 1),即(1/2)n(n-1)次。O(n^2)。
平均:O(n^2)
空间复杂度:只有一个额外变量,所以为O(1)

折半插入算法

public static void binaryInsertSort(int[] array) {
        int temp;
        int low = 0;
        int high;
        int middle;
        for (int i = 1; i <= array.length - 1; i++) {
            temp = array[i];
            low = 0;
            high = i - 1;
            while (low <= high) {
                middle = (low + high) / 2;
                if (temp < array[middle]) {
                    high = middle - 1;
                } else {
                    low = middle + 1;
                }
            }
            int j;
            for (j = i - 1; j >= high + 1; j--) {
                array[j + 1] = array[j];
            }
            array[j + 1] = temp;
        }
    }
  • 希尔排序
public static void shellSort(int[] array, int[] numbers) {

        int i, j, temp, m, k, span;
        for (m = 0; m < numbers.length; m++) {
            span = numbers[m];
            for (k = 0; k < span; k++) {
                for (i = k + span; i < array.length; i = i + span) {
                    temp = array[i];
                    j = i - span;
                    while (j > -1 && temp < array[j]) {
                        array[j + span] = array[j];
                        j = j - span;
                    }
                    array[j + span] = temp;
                }
            }


        }

    }

交换排序

冒泡排序
public static void maoPaoSort(int[] array) {
        int n = array.length;
        for (int i = 0; i < (n-1); i++) {
            for (int j = 0; j < (n-1-i); j++) {
                if(array[j]>array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }
快速排序
public static int partition(int[] array,int low,int high) {
        int temp = array[low];
        while(low < high){
            while(low < high && temp <= array[high])
                high--;
            if(low < high)
            array[low++] = array[high];
            while(low < high && temp >= array[low])
                low++;
            if(low < high)
            array[high--] = array[low];
        }
        array[low] = temp;
        return low;
    }

    public static void quickSort(int[] array,int low,int high) {
        int standardLoc;
        if(low<high) {
            standardLoc = partition(array,low,high);
            quickSort(array,low,standardLoc-1);
            quickSort(array,standardLoc+1,high);
        }
    }

    public static int[] oldArray = {4,786,24,65,76,23,15,97,34,48,92,44};
//on call
quickSort(oldArray,0,oldArray.length-1);

选择排序

不断从待排序序列中选择最小的记录放到已经排序的记录后面

public static void swapSort(int[] oldArray){
        int smallIndex;
        int temp;
        int i,j;
        for(i = 0;i<oldArray.length - 1;i++){
            smallIndex = i;
            for(j = i+1;j<oldArray.length;j++){
                if(oldArray[smallIndex] >= oldArray[j]){
                    smallIndex = j;
                }
            }
            if(smallIndex != i){
                temp = oldArray[i];
                oldArray[i] = oldArray[smallIndex];
                oldArray[smallIndex] = temp;
            }
        }
}

比较次数依次为(n-1)、(n-2)、、、1,故时间复杂度 O(n2),空间复杂度O(1);

堆排序:https://blog.csdn.net/qq_36186690/article/details/82505569

相关文章

  • 开发者应该掌握的几种排序算法

    该篇文章主要介绍了算法基础以及几种常见的排序算法:选择排序、插入排序、冒泡排序、快速排序、堆排序。 一、算法基础 ...

  • 算法-排序算法总结

    排序类型总结 1 排序算法基础实现 2 排序算法应用 2.1 基础排序 2.2 计数排序应用 2.3 快排应用 2...

  • 算法与数据结构(二):排序篇-O(n^2)算法:选择 &

    排序基础 O(n^2)的算法虽然简单,但也实用!让我们从最简单的基础排序算法开始,打开我们的算法大门! 排序算法 ...

  • 基础排序算法总结

    排序算法分为内部排序和外部排序,而我们经常说的基础排序算法,都是内部排序算法。包括冒泡排序,选择排序,插入排序,快...

  • 排序算法

    概述 一般排序算法(以元素比较为基础) => 快速排序、归并排序、插入排序、冒泡排序、堆排序 特殊排序算法 => ...

  • 算法汇总

    关于算法: 基础技巧:分治、二分、贪心排序算法:快速排序、归并排序、计数排序搜索算法:回溯、递归、深度优先遍历,广...

  • 插入排序算法实现

    排序算法是最常见,最基础的算法,作者文集中记录了两种排序算法(插入排序,归并排序) 插入排序算法实现很简单直接,附...

  • 排序算法总结

    基础排序算法 基础排序算法相关接口和实现类 接口: 实现类(后续排序的父类): 1.选择排序 两层循环:内层循环进...

  • 算法与数据结构简介

    0x01 算法 基础技巧:分治、二分、贪心 排序算法:快速排序、归并排序、计数排序 搜索算法:回溯、递归、深度优先...

  • 数据结构与算法—排序(下)

    在上一篇排序算法中介绍了3中基础排序算法:选择排序,插入排序,希尔排序。接下来介绍的两钟排序算法《归并排序》和《快...

网友评论

      本文标题:基础排序算法

      本文链接:https://www.haomeiwen.com/subject/kkjyrctx.html