python基础算法_python基础算法

一些例子

######复杂度O(1)

print("this is wd")

######复杂度O(n)for i inrange(n):

print(i)

######复杂度O(n2)for i inrange(n):for j inrange(n):

print(j)

######复杂度O(n3)for i inrange(n):for j inrange(n):for k inrange(n):

print('wd')

######复杂度O(log2n)while n > 1:

print(n)

n= n //2

常见的复杂度按效率排序：O(1)

空间复杂度

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度。一个算法在计算机存储器上所占用的存储空间，包括存储算法本身所占用的存储空间，算法的输入输出数据所占用的存储空间和算法在运行过程中临时占用的存储空间这三个方面。算法的输入输出数据所占用的存储空间是由要解决的问题决定的，是通过参数表由调用函数传递而来的，它不随本算法的不同而改变。存储算法本身所占用的存储空间与算法书写的长短成正比，要压缩这方面的存储空间，就必须编写出较短的算法。算法在运行过程中临时占用的存储空间随算法的不同而异，有的算法只需要占用少量的临时工作单元，而且不随问题规模的大小而改变，这种算法是节省存储的算法；有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元。

如当一个算法的空间复杂度为一个常量，即不随被处理数据量n的大小而改变时，可表示为O(1)；当一个算法的空间复杂度与以2为底的n的对数成正比时，可表示为0(log2n)；当一个算法的空间复杂度与n成线性比例关系时，可表示为0(n).若形参为数组，则只需要为它分配一个存储由实参传送来的一个地址指针的空间，即一个机器字长空间；若形参为引用方式，则也只需要为其分配存储一个地址的空间，用它来存储对应实参变量的地址，以便由系统自动引用实参变量。

二、python中的常见算法

冒泡排序

效率：O(n2)

原理：

比较相邻的元素，如果第一个比第二个大，就交换他们两个；

对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。做完以后，最后的元素会是最大的数，这里可以理解为走了一趟；

针对所有的元素重复以上的步骤，除了最后一个；

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较，最后数列就是从大到小一次排列；

demo：

# 基本冒泡排序

arr = [1, 3, 56, 34, 45, 32, 2, 34, 45, 67]

def bubble_sort1(arr):

# 外层循环累计排序轮数，同时控制待排序数组的上边界，即A[0..i]为待排序部分

# 内层循环扫描A[0..i-1]，比较相邻元素，并通过交换元素值的方式将最大值放到最后一位

for i in range(len(arr)-1,0,-1): # 趟数

# print("arr[%d]=%s" % (i,arr[i]))

for index in range(len(arr) - i - 1): # 遍历数据，依次交换

if arr[index] > arr[index + 1]:

arr[index], arr[index + 1] = arr[index + 1], arr[index]

bubble_sort1(arr)

print(arr)

优化版本：当某一趟走完以后发现并没有进行数据交换，那么此时的数列已经排列好了，没有必要在进行下去。例如：极端情况下，数列本来已经排序好的，我们只需要走一趟即可完成排序。

# 算法二：冒泡排序改进，设置交换操作标志

def bubble_sort2(arr):

for i in range(len(arr) - 1, 0, -1): #趟数

swapFlag = False # 先假设未做交换

for j in range(0, i):

if arr[j] > arr[j + 1]:

arr[j], arr[j + 1] = arr[j + 1], arr[j]

swapFlag = True # 改变交互操作标志

if swapFlag == False:

break # 无交换操作，表示已完成排序，退出循环也可以写成if not swapFlag:

return i # 返回循环的次数

bubble_sort2(arr)

print(arr)

选择排序

效率：O(n2)

原理：

每一次从待排序的列表中选出一个元素，并将其与其他数依次比较，若列表中的某个数比选中的数小，则交换位置，把所有数比较完毕，则会选出最小的数，将其放在最左边（这一过程称为一趟）；

重复以上步骤，直到全部待排序的数据元素排完；

demo：

def select_sort(lists):

"""

选择排序

:param data: 待排序的数据列表

:return:

"""

for i in range(len(lists) - 1): # 趟数

min_value = i # 记录i趟开始最小数的索引

for j in range(i + 1, len(lists)): # 每一次趟需要循环的次数

if lists[min_value] > lists[j]: # 当数列中的某一个数比开始的数要小时候，更新最小值索引位置

min_value = j

# 一趟走完，交换最小值的位置，第一趟最小

lists[min_value], lists[i] = lists[i], lists[min_value]

return lists

print(select_sort(arr))

插入排序

效率：O(n2)

原理：

以从小到大排序为例，元素0为第一个元素，插入排序是从元素1开始，尽可能插到前面。

插入时分插入位置和试探位置，元素i的初始插入位置为i，试探位置为i-1，在插入元素i时，依次与i-1,i-2······元素比较，如果被试探位置的元素比插入元素大，那么被试探元素后移一位，元素i插入位置前移1位，直到被试探元素小于插入元素或者插入元素位于第一位。

重复上述步骤，最后完成排序

demo：

def insert_sort(data):

"""

插入排序

:param data: 待排序的数据列表

:return:

"""

for i in range(1, len(data)): # 无序区域数据

tmp = data[i] # 第i次插入的基准数

for j in range(i, -1, -1):

if tmp < data[j - 1]: # j为当前位置，试探j-1位置

data[j] = data[j - 1] # 移动当前位置

else: # 位置确定为j

break

data[j] = tmp # 将当前位置数还原

print(select_sort(arr))

第二种：

def insert_sort(arr):

"""

插入排序

:param data: 待排序的数据列表

:return:

"""

for i in range(len(arr)):

preindex = i - 1

current = arr[i]

while preindex >= 0 and arr[preindex] > current:

arr[preindex + 1] = arr[preindex]

preindex -= 1

arr[preindex + 1] = current

return arr

print(insert_sort(arr))

快速排序

效率:平均O(nlogn)

原理：

从数列中随机挑选出一个数作为基数；

重新排列数列，使得比基数小的元素在左边，比基数大元素在右边，相等的元素放左边或者右边都可以，最后使得该基数在处于数列中间位置，这个称为分区操作；

递归上述操作，完成排序，如下如；

demo:

arr = [1, 3, 56, 34, 45, 32, 2, 34, 45, 67]

def quick_sort(data,left,right):

"""

快速排序

:param data: 待排序的数据列表

:param left: 基准数左边元素的索引

:param right: 基准数右边元素的索引

:return:

"""

if left < right:

mid = partition(data,left,right) # 分区操作,mid代表基数所在的索引

quick_sort(data,left,mid-1) # 对基准数前面进行排序

quick_sort(data,mid+1,right) # 对基准数后面进行排序

def partition(data,left,right):

tmp=data[left] # 随机选择的基准数,从最左边开始选

while left < right:

while left < right and data[right] >= tmp: # 右边的数比基准数大

right-=1 # 保留该数，然后索引指针往左移动

data[left]=data[right] # 否则此时右边数比基数小，则将该数放到基准位置

while left < right and data[left] <= tmp: # 右边的数比基准数小

left+=1 # 此时保持该数位置不动，索引指针往前移动

data[right]=data[left] # 否则此时左边的数比基数大，则将该数放到右边

data[left] = tmp # 最后将基准数量放回中间

return left # 返回基准数位置

if __name__=='__main__':

quick_sort(arr,0,len(arr)-1)

print(arr)