四种排序算法实现

目录

  • 冒泡排序

    • 冒泡算法
    • 源代码(冒泡排序)
  • 选择排序
    • 选择算法
    • 源代码(选择排序)
  • 插入排序
    • 插入算法
    • 源代码(插入排序)
  • 快速排序
    • 快速排序算法
    • 源代码(快速排序)
  • 总结
  • References

冒泡排序

冒泡算法

  1. 比较相邻的元素。如果左边比右边大,就互换位置
  2. 对每一对相邻元素作同样的工作,从第一对到最后一对,完成后,最后元素为最大值

源代码(冒泡排序)

//冒泡排序
public static void bubbleSort(int[] slist) {
//从头开始遍历
    for(int i = 0;i < slist.length-1; i++) {
        //一一对比
        for(int j = i+1;j < slist.length; j++) {
        //如果前面的数大于后边的数,冒泡往后排
        if(slist[i] > slist[j]) {
            //交换两个值
                int temp = slist[i];
                slist[i] = slist[j];
                slist[j] = temp;
            }
        }
//System.out.println(Arrays.toString(slist));
    }
}

选择排序

选择算法

  1. 找到数组中最大或者最小的元素,将它和数组的第一个元素交换位置
  2. 剩下的元素中,最小值与第二个元素交换位置

源代码(选择排序)

//选择排序
public static void selectionSort(int[] slist) {

    //利用循环进行遍历
    for(int i = 0;i < slist.length;i++ ) {
        //假设第一个值为最小值
        int min = i;
        //遍历获取最小值位置
        for(int j = i; j < slist.length;j++) {
            if(slist[min] > slist[j]) {
                min = j;
            }
        }
        //将该位置与小值交换
        int temp = slist[i];
        slist[i] = slist[min];
        slist[min] = temp;
    }
}

插入排序

插入算法

  1. 从第一个元素开始,将此元素视为已排序
  2. 取下一元素,在已经排序的序列中从后向前扫描
  3. 如果已排序序列元素大于待插入元素,将序列元素后移
  4. 重复步骤3,直到找到适合位置
  5. 将新元素插入到该位置后
  6. 重复2~5

源代码(插入排序)

//插入排序
public static void insertSort(int[] slist) {
    //将list[i]插入到list[0]...list[i-1]中
    for(int i = 1; i < slist.length;i++) {
        int temp = slist[i];
        int j = i-1;
        //将值往后移动
        for(;j >= 0 && slist[j] > temp;j--) {
            slist[j+1] = slist[j];
        }
        //在适当位置插入该值
        slist[j+1] = temp;
    }
}

快速排序

快速排序算法

  1. 从序列中挑出一个元素作为“基准”(一般采用中间元素)
  2. 重新排序数列,所有比基准值小的元素摆放在基准前面,所有比基准值大的元素摆在基准后面(相同的数可以到任何一边)。
  3. 递归地把小于基准值元素的子序列和大于基准值元素的子序列排序。

源代码(快速排序)

public static void quickSort(int[] slist,int head, int tail) {
    //如果该段一第一个下标值等于最后一个下标值,序列为空,序列长度小于等于1,结束
    if(head >= tail || slist == null || slist.length <= 1) {
        return ;
    }
    //head,tail值递归时仍需使用,因此定义i&j,取mid为基准
    int i = head,j = tail, mid = slist[(head+tail)/2];
    //因为i值会慢慢和j值接近,所以当i小于或等于j时保持循环,对比基准两边的值,将大于基准值的移到基准右边,将小于基准值的移到基准值左边
    while(i < j) {
        //在序列左边寻找大于基准的值
        while(slist[i] < mid && i < j) { ++i; }
        //在序列右边寻找小于基准的值
        while(slist[j] > mid && i < j) { --j; }
        //如果i等于j,退出当前循环
        if(i == j) { break; }
        //交换两个位置的值
        int temp = slist[i];
        slist[i] = slist[j];
        slist[j] = temp;
    }
    // 左边子序列递归
    quickSort(slist, head, i-1);
    //右边子序列递归
    quickSort(slist, i+1 , tail);
}

总结

名称 稳定性 时间复杂度 空间复杂度
冒泡排序 稳定 O(n^2) O(1)
选择排序 不稳定 O(n^2) O(1)
插入排序 稳定 O(n^2) O(1)
快速排序 不稳定 O(n log n)(最坏O(n^2)) O(log n)

References

插入排序

排序算法

原文地址:https://www.cnblogs.com/glasses/p/10549643.html

时间: 2024-11-08 08:57:09

四种排序算法实现的相关文章

四种排序算法PHP实现类

四种排序算法的PHP实现:1) 插入排序(Insertion Sort)的基本思想是: 每次将一个待排序的记录,按其关键字大小插入到前面已经排好序的子文件中的适当位置,直到全部记录插入完成为止. 2) 选择排序(Selection Sort)的基本思想是: 每一趟从待排序的记录中选出关键字最小的记录,顺序放在已排好序的子文件的最后,直到全部记录排序完毕. 3) 冒泡排序的基本思想是: 两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止. 4) 快速排序实质上和

常用的四种排序算法

#include <stdio.h> void BubbleSort(int a[], int size, int order); void SelectSort(int a[], int size, int order); void InsertSort(int a[], int size, int order); void QuickSort(int a[], int size, int order); int main() { int a[5]={5,3,4,2,1}; int i; /

四种排序算法的时间比较

#include<iostream> #include<time.h> using namespace std; template<class T> inline void Swap(T& a, T& b); template<class T> void BubbleSort(T a[], int n); template<class T> void InsertionSort(T a[], int n); template<

php中的四种排序算法

1 1. 冒泡排序 2 3 思路分析:在要排序的一组数中,对当前还未排好的序列,从前往后对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒.即,每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换. 4 5 代码实现: 6 7 8 $arr=array(1,43,54,62,21,66,32,78,36,76,39); 9 function bubbleSort($arr) 10 { 11 $len=count($arr); 12 //该层循环控制 需要冒泡的轮数 13

四种排序算法与二分查找

1. 冒泡排序 func BubbleSort(slice []int) []int { i, j, okay, count := 0, 0, true, len(slice) for i = 0; i < count-1; i++ { //最多需要进行count-1轮比较 okay = true for j = 0; j < count-i-1; j++ { //每一轮比较的逻辑 if slice[j] > slice[j+1] { slice[j], slice[j+1] = sli

PHP四种基础算法详解

许多人都说 算法是程序的核心,一个程序的好于差,关键是这个程序算法的优劣.作为一个初级phper,虽然很少接触到算法方面的东西 .但是对于冒泡排序,插入排序,选择排序,快速排序四种基本算法,我想还是要掌握的. 需求:分别用 冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中 的值按照从小到的顺序进行排序. $arr=array(11,3,56,62,21,66,32,78,36,76,39,88,34); 1.冒泡排序 介绍: 冒泡排序(Bubble Sort,台湾译为:泡沫排序或气泡排

几种排序算法比较

图解数据结构(10)——排序 十四.排序(Sort) http://www.cppblog.com/guogangj/archive/2009/11/13/100876.html <Thinking in Algorithm>12.详解十一种排序算法 http://blog.csdn.net/speedme/article/details/23021467

总结N种排序算法及实现

排序算法是一个简单的问题,但在此问题上却有大量的研究!当前的排序算法通常按照如下四个方面进行分类(或是评价): 1.时间复杂度:一个排序算法的理想性能是O(n).一般而言,好的性能O(nlogn),坏的性能O(n2). 2.空间复杂度(内存使用量) 3.稳定性:稳定的排序算法会让原本有相等键值的记录维持原本的相对次序. 4.排序方式:插入.交换.选择.合并等 一.冒泡排序:这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端. 步骤:1.比较相邻的两个元素,如果第一个比第二个大,就

php四种基础算法:冒泡,选择,插入和快速排序法

转自:http://www.php100.com/html/php/rumen/2013/1029/6333.html 许多人都说 算法是程序的核心,一个程序的好于差,关键是这个程序算法的优劣.作为一个初级phper,虽然很少接触到算法方面的东西 .但是对于冒泡排序,插入排序,选择排序,快速排序四种基本算法,我想还是要掌握的.下面是我按自己的理解,将四个方法分析一遍. 需求:分别用 冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中 的值按照从小到的顺序进行排序. $arr(1,43,5