Python3 实例（八）

Python 归并排序

归并排序（英语：Merge sort，或mergesort），是创建在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

分治法:

分割：递归地把当前序列平均分割成两半。

集成：在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

实例

def merge(arr, l, m, r):
n1 = m - l + 1
n2 = r- m

# 创建临时数组
L = [0] * (n1)
R = [0] * (n2)

# 拷贝数据到临时数组 arrays L[] 和 R[] 
for i in range(0 , n1): 
    L[i] = arr[l + i] 

for j in range(0 , n2): 
    R[j] = arr[m + 1 + j] 

# 归并临时数组到 arr[l..r] 
i = 0     # 初始化第一个子数组的索引
j = 0     # 初始化第二个子数组的索引
k = l     # 初始归并子数组的索引

while i < n1 and j < n2 : 
    if L[i] <= R[j]: 
        arr[k] = L[i] 
        i += 1
    else: 
        arr[k] = R[j] 
        j += 1
    k += 1

# 拷贝 L[] 的保留元素
while i < n1: 
    arr[k] = L[i] 
    i += 1
    k += 1

# 拷贝 R[] 的保留元素
while j < n2: 
    arr[k] = R[j] 
    j += 1
    k += 1

def mergeSort(arr,l,r):
if l < r:

    m = int((l+(r-1))/2)

    mergeSort(arr, l, m) 
    mergeSort(arr, m+1, r) 
    merge(arr, l, m, r) 

arr = [12, 11, 13, 5, 6, 7]
n = len(arr)
print ("给定的数组")
for i in range(n):
print("%d" %arr[i]),

mergeSort(arr,0,n-1)
print ("\n\n排序后的数组")
for i in range(n):
print ("%d" %arr[i]),
执行以上代码输出结果为：

给定的数组121113567
排序后的数组567111213
Python 堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。

实例

def heapify(arr, n, i):
largest = i
l = 2 i + 1 # left = 2i + 1
r = 2 i + 2 # right = 2i + 2

if l < n and arr[i] < arr[l]: 
    largest = l 

if r < n andarr[largest] < arr[r]: 
    largest = r 

if largest != i: 
    arr[i],arr[largest] = arr[largest],arr[i]  # 交换

    heapify(arr, n, largest) 

def heapSort(arr):
n = len(arr)

# Build a maxheap. 
for i in range(n, -1, -1): 
    heapify(arr, n, i) 

# 一个个交换元素
for i in range(n-1, 0, -1): 
    arr[i], arr[0] = arr[0], arr[i]   # 交换
    heapify(arr, i, 0) 

arr = [ 12, 11, 13, 5, 6, 7]
heapSort(arr)
n = len(arr)
print ("排序后")
for i in range(n):
print ("%d" %arr[i]),
执行以上代码输出结果为：

排序后
5
6
7
11
12
13
Python 计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

实例

def countSort(arr):

output = [0 for i in range(256)] 

count = [0 for i inrange(256)] 

ans = ["" for _ in arr] 

for i in arr: 
    count[ord(i)] += 1

for iin range(256): 
    count[i] += count[i-1] 

for i in range(len(arr)): 
    output[count[ord(arr[i])]-1] = arr[i] 
    count[ord(arr[i])] -= 1

for i inrange(len(arr)): 
    ans[i] = output[i] 
return ans  

arr = "wwwrunoobcom"
ans = countSort(arr)
print ( "字符数组排序 %s" %("".join(ans)) )
执行以上代码输出结果为：

符数组排序 bcmnoooruwww
Python 希尔排序

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。

希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

实例

def shellSort(arr):

n = len(arr)
gap = int(n/2)

while gap > 0: 

    for i inrange(gap,n): 

        temp = arr[i] 
        j = i 
        while  j >= gap and arr[j-gap] >temp: 
            arr[j] = arr[j-gap] 
            j -= gap 
        arr[j] = temp 
    gap = int(gap/2)

arr = [ 12, 34, 54, 2, 3]

n = len(arr)
print ("排序前:")
for i inrange(n):
print(arr[i]),

shellSort(arr)

print ("\n排序后:")
for i in range(n):
print(arr[i]),
执行以上代码输出结果为：

排序前:
12
34
54
2
3
排序后:
2
3
12
34
54
Python 拓扑排序

对一个有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序，是将G中所有顶点排成一个线性序列，使得图中任意一对顶点u和v，若边(u,v)∈E(G)，则u在线性序列中出现在v之前。

通常，这样的线性序列称为满足拓扑次序(Topological Order)的序列，简称拓扑序列。简单的说，由某个集合上的一个偏序得到该集合上的一个全序，这个操作称之为拓扑排序。

在图论中，由一个有向无环图的顶点组成的序列，当且仅当满足下列条件时，称为该图的一个拓扑排序（英语：Topological sorting）：

每个顶点出现且只出现一次；

若A在序列中排在B的前面，则在图中不存在从B到A的路径。

实例

from collections import defaultdict

class Graph:
def init(self,vertices):
self.graph = defaultdict(list)
self.V = vertices

def addEdge(self,u,v): 
    self.graph[u].append(v) 

def topologicalSortUtil(self,v,visited,stack): 

    visited[v] = True

    for i in self.graph[v]: 
        if visited[i] == False: 
            self.topologicalSortUtil(i,visited,stack) 

    stack.×××ert(0,v) 

deftopologicalSort(self): 
    visited = [False]*self.V 
    stack =[] 

    for i inrange(self.V): 
        if visited[i] == False: 
            self.topologicalSortUtil(i,visited,stack) 

    print (stack) 

g= Graph(6)
g.addEdge(5, 2);
g.addEdge(5, 0);
g.addEdge(4, 0);
g.addEdge(4, 1);
g.addEdge(2, 3);
g.addEdge(3, 1);

print ("拓扑排序结果：")
g.topologicalSort()
执行以上代码输出结果为：

拓扑排序结果：
[5, 4, 2, 3, 1, 0]
最后免费赠送一个实例：

Python 计算笛卡尔积

计算多个集合的笛卡尔积，有规律可循，算法和代码也不难，但是很多语言都没有提供直接计算笛卡尔积的方法，需要自己写大段大段的代码计算笛卡尔积，python 提供了一种最简单的计算笛卡称积的方法(只需要一行代码)，详见下面的代码：
#!/usr/bin/python3

-- coding: utf-8 --

@file : Cartesian.py

@author : shlian

@date : 2018/5/29

@version: 1.0

@desc : 用python实现求笛卡尔积

import itertools

class cartesian(object):
def init(self):
self._data_list=[]

def add_data(self,data=[]): #添加生成笛卡尔积的数据列表
    self._data_list.append(data)

def build(self): #计算笛卡尔积
    for item in itertools.product(*self._data_list):
        print(item)

if name=="main":
car=cartesian()
car.add_data([1,2,3,4])
car.add_data([5,6,7,8])
car.add_data([9,10,11,12])
car.build()
计算的结果如下：
(1, 5, 9)
(1, 5, 10)
(1, 5, 11)
(1, 5, 12)
(1, 6, 9)
(1, 6, 10)
(1, 6, 11)
(1, 6, 12)
(1, 7, 9)
(1, 7, 10)
(1, 7, 11)
(1, 7, 12)
(1, 8, 9)
(1, 8, 10)
(1, 8, 11)
(1, 8, 12)
(2, 5, 9)
(2, 5, 10)
(2, 5, 11)
(2, 5, 12)
(2, 6, 9)
(2, 6, 10)
(2, 6, 11)
(2, 6, 12)
(2, 7, 9)
(2, 7, 10)
(2, 7, 11)
(2, 7, 12)
(2, 8, 9)
(2, 8, 10)
(2, 8, 11)
(2, 8, 12)
(3, 5, 9)
(3, 5, 10)
(3, 5, 11)
(3, 5, 12)
(3, 6, 9)
(3, 6, 10)
(3, 6, 11)
(3, 6, 12)
(3, 7, 9)
(3, 7, 10)
(3, 7, 11)
(3, 7, 12)
(3, 8, 9)
(3, 8, 10)
(3, 8, 11)
(3, 8, 12)
(4, 5, 9)
(4, 5, 10)
(4, 5, 11)
(4, 5, 12)
(4, 6, 9)
(4, 6, 10)
(4, 6, 11)
(4, 6, 12)
(4, 7, 9)
(4, 7, 10)
(4, 7, 11)
(4, 7, 12)
(4, 8, 9)
(4, 8, 10)
(4, 8, 11)
(4, 8, 12)

好了，本文就给大伙分享到这里，文末分享一波福利

获取方式：加python群 839383765 即可获取！