python 冒泡和快排,不多说【无聊】

 1 #-*-coding:utf8-*-
 2 import random
 3 a=[]
 4 b=[]
 5 def init_array():
 6     for i in range(10000):
 7         v = random.randint(1,10000)
 8         a.append(v)
 9         b.append(v)
10
11 #冒泡
12 def sort_array(a):
13         for i in range(len(a)):
14                 for j in range(i+1,len(a)):
15                     if a[i] > a[j]:
16                         i_v = a[i]
17                         a[i]=a[j]
18                         a[j]=i_v
19
20
21 #快排
22 def quick_sort(a,left,right):
23     if left < right:
24         key = a[left]
25         low = left
26         high = right
27         while low<high:
28             while low<high and a[high]>=key:
29                 high-=1
30             a[low] = a[high]
31             while low<high and a[low]<=key:
32                 low+=1
33             a[high]=a[low]
34         a[low]=key
35         quick_sort(a,left,low-1)
36         quick_sort(a,low+1,right)
37
38
39 init_array()
40
41 print "a",len(a)
42 print "b",len(b)
43
44 sort_array(a)
45 quick_sort(b,0,len(b)-1)
46
47 print a,len(a)
48 print b,len(b)

以上保存为 sort.py,然后:python  -m cProfile  sort.py

冒泡时间复杂度O(n^2)快排最差O(n^2),平均O(n*lgn)
时间: 2024-12-22 13:12:19

python 冒泡和快排,不多说【无聊】的相关文章

python 版 quicksort 快排

今天看了下苹果xml 解析,写了个小demo 心想还是 在博客上写点东西吧,毕竟很久很久都没有上来了 先上个效果图把 接下来 看下 工程目录图吧 本demo 分两种解析模式,一是苹果自带的, 首先先看下苹果自带的吧,工程文件为 NoteXMLParser 文件 ,另一种解析模式 是 NotesTBXMLParser文件 NoteXMLParser.h 文件代码如下 : // // NoteXMLParser.h // TestXML // // Created by choni on 14-5-

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

冒泡排序,往两个方向泡,一个往小泡,一个网大泡 #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实现排序(冒泡、快排、归并)

Thomas H.Cormen 的<算法导论>上介绍的几个经典排序算法的Python实现. 1.冒泡排序: 简单的两重循环遍历,使最小(最大)的值不断地往上升(下沉)而实现的排序,算法时间为O(n2). 代码如下: 1 def up_sort(a): 2 # 冒泡排序 3 4 a_length = len(a) 5 while True: 6 i = 0 7 j = 1 8 9 while True: 10 if a[i] > a[j]: 11 a[i], a[j] = a[j], a[

冒泡,快排代码+注释

冒泡: package Sort; public class BubbleSort { public static void main(String[] args) { int[] list = new int[]{12,14,3,24,1,33}; int[] nums = bubbleSort(list); for(int i = 0;i< list.length;i++){ System.out.println(nums[i]); } } public static int[] bubbl

用python写个快排

快排过程比较简单就直接上代码了: 1 #!/usr/bin/python3 2 3 def quik_sort(L, left, right): 4 if left <= right: 5 key = L[left] 6 i = left 7 j = right 8 while i < j: 9 while i < j and key <= L[j]: 10 j -= 1 11 L[i] = L[j] 12 while i < j and L[i] <= key: 13

排序算法的简单实现(冒泡和快排)

排序算法 冒泡排序 原理:把相邻的元素两两比较,根据大小来交换元素的位置. 原始的冒泡排序是稳定排序.由于该排序的每一轮要遍历所以元素,轮转的次数和元素数量相当,所以时间复杂度是 O(N^2). java代码表达如下: import java.util.Arrays; public class BubbleSort{ private static void sort(int array[]){ int tmp = 0; for (int i = 0; i < array.length; i++)

Java实现的各种排序算法(包括冒泡,快排等)

//堆排序 不稳定 import java.util.Arrays; public class HeapSort { public static void main(String[] args) { int[] a={49,38,65,97,76,13,27,49,78,34,12,64}; int arrayLength=a.length; //循环建堆 for(int i=0;i<arrayLength-1;i++){ //建堆 buildMaxHeap(a,arrayLength-1-i)

iOS常见算法(二分法 冒泡 选择 快排)

二分法: 平均时间复杂度:O(log2n) int halfFuntion(int a[], int length, int number) { int start = 0; int end = length - 1; int index = 0; while(start < end) { index = start + (end - start)/2 if(a[index] == number){ return index; } else if(a[index] < number){ sta

Java常见的几种排序算法-插入、选择、冒泡、快排、堆排等

本文就是介绍一些常见的排序算法.排序是一个非常常见的应用场景,很多时候,我们需要根据自己需要排序的数据类型,来自定义排序算法,但是,在这里,我们只介绍这些基础排序算法,包括:插入排序.选择排序.冒泡排序.快速排序(重点).堆排序.归并排序等等.看下图: 给定数组:int data[] = {9,2,7,19,100,97,63,208,55,78} 一.直接插入排序(内部排序.O(n2).稳定) 原理:从待排序的数中选出一个来,插入到前面的合适位置. [java] view plain copy