常用算法之 冒泡、选择、插入、快排

常用简单算法

一、冒泡排序

冒泡排序的基本思想是,对相邻的元素进行两两比较,假设这连个数字是, a、b 同时排序规则是升序,如果a>b 则他们位置进行交换,这样,每一趟会将最小或最大的元素“浮”到顶端,最终达到完全有序.

大概明白是什么意思了就详细的看下下面这张动图,进一步理解

冒泡排序关键点:

  趟    趟就是我们完成整个排序所需要的次数,一次能认一个数据的位置

  无序区   无序区就是没经过排序的数据

def bubble_sort(li):
    # 确认排序完成所需要循环的次数 -1 是因为最后一个数据不需要循环  趟
    for i in range(len(li) - 1):
        # 无序区
        for j in range(len(li) -i - 1 ):
            if li[j] > li[j+1]:
                li[j], li[j+1] = li[j+1],li[j]

li = [2,1,3,5,8,88,22,33]
bubble_sort(li)
print(li)

二、选择排序

它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

思路:

一趟遍历记录最小的数,放到第一个位置;

再一趟遍历记录剩余列表中最小的数,继续放置;

图解:

代码实现

def select_sort(li):
    for i in range(len(li) - 1):
        # 定义基准数值
        mid = i
        # 从当前位置后一个下标开始循环
        for j in range(i + 1,len(li)):
            if li[j] < li[mid]:
                li[j], li[mid] = li[mid], li[j]

select_sort(li)

三、插入排序

插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据,算法适用于少量数据的排序。是稳定的排序方法。

列表被分为有序区和无序区两个部分。最初有序区只有一个元素。

每次从无序区选择一个元素,插入到有序区的位置,直到无序区变空。

图解:

def insert_sort(li):
    for i in range(1,len(li)):
        tmp = li[i]
        j = i - 1
        while j >= 0 and tmp < li[j]:
            li[j + 1] = li[j]
            j = j - 1
        li[j + 1] = tmp

ps:

  

  冒泡排序 插入排序 选择排序

  时间复杂度:O(n2)

  空间复杂度:O(1)

四、快排

  取一个元素p(第一个元素),使元素p归位;

  列表被p分成两部分,左边都比p小,右边都比p大;

   递归完成排序。

  在最优的情况下,快速排序算法的时间复杂度为O(nlogn)。

#### 快速排序
def partition(li, left, right):
    tmp = li[left]
    while left < right:

        while left < right and li[right] > tmp:
            right = right - 1
        li[left] = li[right]

        while left < right and li[left] < tmp:
            left = left + 1
        li[right] = li[left]

    li[left] = tmp

    return left

def quickSort(li, left, right):

    if left < right:
        mid = partition(li, left, right)
        quickSort(li, left, mid - 1)
        quickSort(li, mid+1, right)

quickSort(li, 0, len(li)-1)
print(li)

更详细简单的快排

https://blog.csdn.net/pythondafahao/article/details/80084385

原文地址:https://www.cnblogs.com/yangwei666/p/9580570.html

时间: 2024-08-29 04:58:17

常用算法之 冒泡、选择、插入、快排的相关文章

排序算法-冒泡——插入——快排

冒泡排序,往两个方向泡,一个往小泡,一个网大泡 #include<stdio.h> #include<stdlib.h> #include<time.h> void bubble_sort(int *a,int n){ int temp; for(int i=0;i<n;i++) for(int j=0;j<n-i-1;j++){ if(a[j]>a[j+1]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } v

python 数据结构与算法之排序(冒泡,选择,插入)

目录 数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 数据结构与算法: 算法: 数据结构 冒泡排序法 选择排序法 插入排序法 数据结构与算法之排序(冒泡,选择,插入) 为什么学习数据结构与算法: 计算机重要的几门课: 1.数据结构和算法 2.网络 3.操作系统 4.计算组成原理 数据结构与算法: 算法: 衡量算法的标准: 时间复杂度:就是程序代码执行的大概次数 小结: 时间复杂度是用来估计算法运行时间的一个式子(单位) 一般来说,时间复杂度高的算法比复杂度低的算法慢 常见的

算法总结——三大排序(快排,计数排序,归并)

快排: 适用条件:方便...只要数字不是很多 复杂度:O(nlogn)  每一层n复杂度,共logn层 原理:利用一个随机数与最后面一个数交换,那么这个随机数就到了最后一位,然后循环,如果前面的数大于最后一个数,那么把这个数放到前面去,经过一次排序之后,前面的数都是大于最后一个的,然后对1到k和k+1到n进行排序,一层一层地下去 模板: #include<cstdio> #include<algorithm> #include<time.h> using namespa

排序算法之冒泡、插入、快排和选择排序

排序算法大全 package cn.baidu; import java.util.Arrays; public class SortTest { public static void main(String[] args) { int[] arr = { 2, 5, 3, 1, 4 }; System.out.println("排序前:" + Arrays.toString(arr)); // InsertSort.sort(arr); // BubbleSort.sort(arr)

基本排序算法(冒泡、插入、选择、快排)

1.首先定义一个需要排序的数组: $arr=array(12,432,123,454,232,123,349,3,5,745,90); 2.冒泡排序:相邻之间的数据做对比,每次对比后得出一个下次不需要再对比的数据. function maopao($arr){ $len=count($arr); for($i=0;$i<$len;$i++){ for($j=0;$j<$len-$i;$j++){ if($arr[$j]<$arr[$j+1]){ $temp=$arr[$j; $arr[$

冒泡选择插入快速,四种最基础排序算法实现

<?php /** * Created by PhpStorm. * User: chm * Date: 2016/4/1 * Time: 19:35 */ //插入排序特点是一边是排好顺序的,另一边一个一个和顺序的数据对比,每次对比插入一个 function charu($arr) { $len = count($arr); //先给出一个原数组 echo "原数组为:"; for($y = 0;$y < $len;$y++){ echo $arr[$y]; } echo

冒泡 选择 插入 希尔 堆 归并 快速 排序算法

排序相关概念 排序:对一序列对象根据某个关键字进行排序: 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面: 不稳定:如果a原本在b的前面,而a=b,排序之后a可能会出现在b的后面: 内排序:所有排序操作都在内存中完成: 外排序:由于数据太大,因此把数据放在磁盘中,而排序通过磁盘和内存的数据传输才能进行: 排序耗时的操作:比较.移动: 排序分类: (1)交换类:冒泡排序.快速排序:此类的特点是通过不断的比较和交换进行排序: (2)插入类:简单插入排序.希尔排序:此类的特点是通过插入的

【算法】5 传说中的快排是如何的

什么是高速排序 高速排序简单介绍 高速排序(英文名:Quicksort,有时候也叫做划分交换排序)是一个高效的排序算法,由Tony Hoare在1959年发明(1961年发布).当情况良好时.它能够比主要竞争对手的归并排序和堆排序快上大约两三倍.这是一个分治算法,并且它就在原地排序. 所谓原地排序,就是指在原来的数据区域内进行重排.就像插入排序一般. 而归并排序就不一样,它须要额外的空间来进行归并排序操作.为了在线性时间与空间内归并,它不能在线性时间内实现就地排序,原地排序对它来说并不足够.而高

java中各种经典排序(冒泡 选择 插入 希尔等)

1 import java.util.Arrays; 2 3 public class ArraySort { 4 public static void main(String[] args) { 5 int[] arr = { 12, 23, 14, 5, 64, 35, 42 }; 6 System.out.println("排序前:"); 7 System.out.println(Arrays.toString(arr)); 8 // bubbleSort(arr); 9 //