用python实现插入排序和冒泡排序

插入排序和冒泡排序的概念我就不解释了吧

。。。插入排序代码:

 1 if __name__ ==‘__main__‘:
 2     l = [4,1,9,13,34,26,10,7,4]
 3
 4 #=========================insert_sort=========================
 5     def insert_sort(l):
 6         for i in range(len(l)):
 7             min_index = i
 8             for j in range(i+1,len(l)):
 9                 if l[min_index] > l[j]:
10                     min_index = j
11             tmp = l[i]
12             l[i] = l[min_index]
13             l[min_index] = tmp
14             print(str(l))
15         print("result: " + str(l))
16
17     insert_sort(l)
18     print("insert_sort success!!!")

每次遍历,先假设list[min_index]处的值最小,再跟后面的值依次比较,当发现list[j]比list[min_index]值小时,这时的min_index替换为j,再跟后面的进行比较,指导找到最小的那个list[j],将j付给min_index,这时l[min_index]就是遍历过程中的最小值了,不知道说清楚了没~~

结果如下:

[1, 4, 9, 13, 34, 26, 10, 7, 4]
[1, 4, 9, 13, 34, 26, 10, 7, 4]
[1, 4, 4, 13, 34, 26, 10, 7, 9]
[1, 4, 4, 7, 34, 26, 10, 13, 9]
[1, 4, 4, 7, 9, 26, 10, 13, 34]
[1, 4, 4, 7, 9, 10, 26, 13, 34]
[1, 4, 4, 7, 9, 10, 13, 26, 34]
[1, 4, 4, 7, 9, 10, 13, 26, 34]
[1, 4, 4, 7, 9, 10, 13, 26, 34]
result: [1, 4, 4, 7, 9, 10, 13, 26, 34]
insert_sort success!!!

下面再来看冒泡排序

 1 #==========================bubble_sort========================
 2
 3     def bubble_sort(l):
 4         for i in range(len(l),0,-1):
 5             for j in range(len(l)-1):
 6                 if l[j] > l[j+1]:
 7                     tmp = l[j]
 8                     l[j] = l[j+1]
 9                     l[j+1] = tmp
10
11         print("result: " + str(l))
12
13     bubble_sort(l)
14     print("bubble_sort success!!!")

不解释了。。

时间: 2024-10-14 00:50:20

用python实现插入排序和冒泡排序的相关文章

python 实现插入排序、冒泡排序、归并排序

1 def InsertSort(A): 2 '''插入排序算法:传入一个list,对list中的数字进行排序''' 3 print('插入排序前list元素顺序:',A) 4 length=len(A) 5 for i in range(1,length):#从第二个开始 6 key=A[i] 7 j=i-1 8 while j>=0 and A[j]>key: 9 A[j+1]=A[j] 10 j=j-1 11 A[j+1]=key 12 print('插入排序后的list元素顺序:',A

选择排序、插入排序、冒泡排序python实现

选择排序的时间复杂度为O(n^2),是不稳定的排序 冒泡排序的时间复杂度最好情况下为O(n),最坏情况下为O(n^2),平均情况下为O(n^2),是稳定的排序 插入排序的时间复杂度最好情况下为O(n),最坏情况下为O(n^2),,平均情况下为O(n^2),是稳定的排序 1.选择排序 def selection(lista): leng=len(lista); for i in range(0,leng): index=i; min=lista[i]; for j in range(i,leng)

插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序——C++实现

首先是算法实现文件Sort.h,代码如下: /* * 实现了八个常用的排序算法:插入排序.冒泡排序.选择排序.希尔排序 * 以及快速排序.归并排序.堆排序和LST基数排序 * @author gkh178 */ #include <iostream> template<class T> void swap_value(T &a, T &b) { T temp = a; a = b; b = temp; } //插入排序:时间复杂度o(n^2) template<

C语言实现直接插入排序,冒泡排序以及二分查找(巩固理解记忆)

C语言实现直接插入排序,冒泡排序以及二分查找(巩固理解记忆) 虽然直接插入排序,冒泡排序以及二分查找是算法中最为基础以及老掉牙的话题,但作为一名算法的深爱者,有时候无聊时候总会将这些简单的话题重新理解并敲写一番,目的只是为了得到理解娴熟的程度.而且,我觉得越是简单基础的东西,有时候更应该反复的去敲写,深化它,并最终让其中的思想内化为自己的一部分.待到他日一提起之时,会相当娴熟的"刷刷刷..."几分钟搞定,那就很有成就感了! 因为我喜欢对于一个问题进行实例的剖析,进而再转化为特有的用某种

常见排序算法实现(直接插入排序,冒泡排序,快速排序,建大选择排序)

常见的排序算法实现(直接插入排序,冒泡排序,快速排序,建大选择排序),还有几个下次写上. #include "stdio.h" #include "stdlib.h" #include "malloc.h" #include <iostream> using namespace std; #define N 10 void showArr(int a[]); void InsertSort(int a[]);    //直接插入排序

python 插入排序 与 冒泡排序

# encoding: utf:8 l = [5, 6, 9, 11, 34, 66, 6, 8, 7] def twoPointSearch(l):     for i in range(len(l)):         min_index = i         for j in range(i+1, len(l)):    #####循环判断得出依次次最小直的索引             if l[min_index] > l[j]:                 min_index =

插入排序和冒泡排序(Swift版本)

插入排序(只记录代码不作详细分析) 插入排序将输入的元素一个个插入到已排序的队列里,对比是由后往前 代码: func insertSort<Elem: Comparable>(_ arr: inout [Elem]) {     for i in 1...arr.count-1 {         let tmp = arr[i]                 for j in (0...i-1).reversed() {             if (j > 0 &&

python 之递归及冒泡排序

一.递归函数 在函数内部,可以调用其他函数,如果一个函数在内部调用本身,这个函数就是递归函数 1.递归的基本原理: 每一次函数调用都会有一次返回.当程序流执行到某一级递归的结尾处时,它会转移到前一级递归继续执行(调用本身函数) 递归函数中,位于递归调用前的语句和各级被调函数具有相同的顺序 虽然每一级递归有自己的变量,但是函数代码并不会得到复制 递归函数中必须包含可以终止递归调用的语句 举例: >>> def fun2(i): ... r = fun2(i+1) ... return r

初试Python语法小试牛刀之冒泡排序

Python很火,心里很慌,没吃过猪肉,也要见见猪走路. 看了几天Python的语法,大概初步了解了一点点,https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000 想综合起来练习一下Python的语法,就从最简答的冒泡排序开始吧. 鉴于Python的灵活性,甚至可以不需要类,不需要main方法,仅仅写个方法然后执行方法就可以运行, 以下简单尝试从类Class的角度来封装一个最最简单的方