算法之常用排序:冒泡排序、选择排序

冒泡排序:

将待排序的元素看作是竖着排列的“气泡”,较小的元素比较轻,从而要往上浮

#!/bin/env python
#_*_ coding:utf-8 _*_
#算法之冒泡排序

li = [13,22,6,99,11]

for m in range(len(li)-1):
    if li[m] > li[m+1]:
        temp = li[m]
        li[m] = li[m+1]
        li[m+1] = temp

#第一次# 13>22 —>pass
#第二次# 22>6  ->li = [13,6,22,99,11]
#第三次# 22>99 ->pass
#第四次# 99>11 ->li = [13,6,22,11,99]
#最大的数字已经找到99,并放在最后,接下来只需要比较前4个数字即可

for m in range(len(li)-2):
    if li[m] > li[m+1]:
        temp = li[m]
        li[m] = li[m+1]
        li[m+1] = temp
#第一次# 13>6  ->li = [6,13,22,11,99]
#第二次# 13>22 ->pass
#第三次# 22>11 ->li = [6,13,11,22,99]
#前4个数字最大数找到22,放在最后,接下来只需比较前3个数字即可

for m in range(len(li)-3):
    if li[m] > li[m+1]:
        temp = li[m]
        li[m] = li[m+1]
        li[m+1] = temp
#第一次# 6>13  ->pass
#第二次# 13>11 ->li = [6,11,13,22,99]
#前3个数字最大数已找到13,放在最后,接来下只需要比较前2个数字即可

for m in range(len(li)-4):
    if li[m] > li[m+1]:
        temp = li[m]
        li[m] = li[m+1]
        li[m+1] = temp
#第一次# 6>11  ->pass
#前2个数字最大数为11,放在最后

print li
#---------------->最终结果为: li=[6,11,13,22,99]

############简化版#############################################################
list = [13,22,6,99,11]
for n in range(1,len(list)-1):    #n=1,2,3,4 #第一次大循环,n=1,m=4
    for m in range(len(list)-n):      #第一次小循环m[0]>m[1],第二次m[1]>m[2],第三次[m2]>[m3],第四次[m3>m4]
        if list[m] > list[m+1]:     #第二次大循环,n=2,m=3
            temp = list[m]            #第一次小循环m[0]>m[1],第二次m[1]>m[2],第三次[m2]>[m3]
            list[m] = list[m+1]     #第三次大循环,n=3,m=2
            list[m+1] = temp          #第一次小循环m[0]>m[1],第二次m[1]>m[2]
                                    #第四次大循环,n=4,m=1
                                      #第一次小循环m[0]>m[1]
print list
#---------------->最终结果为: list=[6,11,13,22,99]

  

选择排序

先选择中间值,然后把比它小的放在左边,大的放在右边(具体的实现是从两边找,找到一对后交换)。然后对两边分别使用这个过程(递归)

#!/bin/env python
#_*_ coding:utf-8 _*_
import time
import random

#生产随机列表
def get_randow():
    list = []
    for x in range(100):
        i = random.randrange(1000)
        list.append(i)
    return list

def select_sort(list):
    for i in range(len(list)):          #for i in range(5) #i=0,1,2,3,4
        for j in range(i,len(list)):        #for j in range(0,5) #i=0,j=0,1,2,3,4
            if list[i] > list[j]:               #if 13>13   ->pass
                tmp = list[i]                   #if 13>22   ->pass
                list[i] = list[j]               #if 13>6    ->list=[6,22,13,99,11]
                list[j] = tmp                   #if 6>99    ->pass
                                                #if 6>11    ->pass
if __name__ == ‘__main__‘:                  #for j in range(1,5) #i=1,j=1,2,3,4
    list = [13,22,6,99,11]                      #if 22>22   ->pass
    #list = get_randow()                        #if 22>13   ->list=[6,13,22,99,11]
    start_time = time.time()                    #if 13>99   ->pass
    select_sort(list)                           #if 13>11   ->list=[6,11,22,99,13]
    end_time = time.time()                  #for j in range(2,5) #i=2,j=2,3,4
    print list                                  #if 22>22   ->pass
    print ‘本次耗时:%s‘%(end_time-start_time)    #if 22>99   ->pass
                                                #if 22>13   ->list=[6,11,13,99,22]
                                            #for j in range(3,5) #i=3,j=3,4
                                                #if 99>99   ->pass
                                                #if 99>22   ->list=[6,11,13,22,99]
                                            #for j in range(3,5) #i=4,j=4
                                                #if 99>99   ->pass

  

时间: 2024-11-08 19:22:58

算法之常用排序:冒泡排序、选择排序的相关文章

【排序】选择排序算法

特别说明 对于算法,重在理解其思想.解决问题的方法,思路.因此,以下内容全都假定待排序序列的存储结构为:顺序存储结构. 选择排序思想 选择排序又称为简单选择排序,主要思想描述如下: 01.假设待排序列表为 .选择排序将  划分为由已排序好序的  部分 以及 未排序的  部分: 注意:刚开始时  部分其实可认为只有一个元素,即: 元素 02.每次从  部分中选出最小(或最大)的那个元素,将其放在  的末尾位置: 03.重复02步骤,直到  部分为空为止: 编码参考 简单选择排序是非常简单的一种排序

排序算法6--选择排序--简单选择排序

简单选择排序 简单选择排序属于选择排序, 选择排序的思想是:每一趟从待排序的记录中选出关键字最小的记录,按顺序放在以排序的记录序列的后面,知道全部排完为止. 1.简单选择排序法是每次循环找出最值,循环结束后将最值调整到合适位置,交换的次数少. 每次找出当前无序队列中的最小的元素与第一个交换位置,再选择第二小的与第二个交换位置 原始队列:   3 5 6 2 4 1(最小元素1与3交换) 第一步: 1 5 6 2 4 3 (当前最小元素2与5交换) 第二步: 1 2 6 5 4 3 (当前最小元素

C# 插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序

以下列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序,然后是測试的样例.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

下面列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序,然后是测试的例子.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

简单排序之选择排序算法JAVA实现

选择排序原理 选择排序是一种简单排序算法.这是一个基于位置比较的算法,通常实现是左边是已经排好序的元素列表,右边是待排序的元素.当然,一开始的时候,我们认为都是未经排序的. 选择排序的精髓:与冒泡排序不同,选择排序是第N趟排序先确定最小元素的位置,然后和第N个元素交换位置.主要特点是每一趟选择一个最小值的索引作为梅一堂最后交换的位置.以一个元素个数为N的整形数组arr为例: 第一趟 以第一个元素arr[0]为基准,准备好一个中间变量temp用来记录该趟最小元素的位置,一开始,temp=0,比较a

算法基础之排序(2)--选择排序 改进

1 /********************************************************************************************************** 2 * Function : test 3 * Create Date : 2014/03/23 4 * Author : NTSK13 5 * Email : [email protected] 6 * Copyright : 欢迎大家和我一起交流学习,转载请保持源文件的完整性

基础算法之排序(2)--选择排序

1 /********************************************************************************************************** 2 * Function : test 3 * Create Date : 2014/03/23 4 * Author : NTSK13 5 * Email : [email protected] 6 * Copyright : 欢迎大家和我一起交流学习,转载请保持源文件的完整性

十大排序算法之(三)——选择排序

#1,选择排序简介 选择排序(Selection sort)是一种简单直观的排序算法.它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完. 选择排序是不稳定的排序方法(比如序列[5, 5, 3]第一次就将第一个[5]与[3]交换,导致第一个5挪动到第二个5后面),我个人认为,按照数值来讲,这两个5没差别,所以这是不是决定这个算法不稳定还有待商榷. #2,c++实现算法 #include<iostream>#include&l

经典排序:冒泡排序+选择排序 小结

经典排序:冒泡排序+选择排序 例 FJUTOJ 1842 冒泡排序 原理是取相邻两个数进行大小比较,判断是否交换. 以从小到大排序为例,冒泡排序就像气泡一样,最小的数慢慢浮上来,最大的数慢慢沉下去.那么完整从头到尾做一次之后最后一位就是原序列中最大的数字了.然后只需要对1~(n-1)个数字进行排序,完成后倒数第二个数字也为原序列的1~n-1元素中最大的值.如此重复,进行n-1次一定能完成排序.参考代码: 1 #include <stdio.h> 2 void BubbleSort(int *,

选择排序—简单选择排序(Simple Selection Sort)

基本思想: 在要排序的一组数中,选出最小(或者最大)的一个数与第1个位置的数交换:然后在剩下的数当中再找最小(或者最大)的与第2个位置的数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后一个数)比较为止. 简单选择排序的示例: 操作方法: 第一趟,从n 个记录中找出关键码最小的记录与第一个记录交换: 第二趟,从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换: 以此类推..... 第i 趟,则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与