python经典算法代码_python实现的几个经典的排序算法

# some complex sorting algorithm

def shell_sort(sort_list):

''' (list) -> None

Sort the sort_list.

'''

increment = len(sort_list)

iter_len = len(sort_list)

while increment > 1:

increment = increment // 3 + 1

for i in range(increment, iter_len):

if sort_list[i] < sort_list[i - increment]:

sentry = sort_list[i]

j = i - increment

while j > -1 and sort_list[j] > sentry:

sort_list[j + increment] = sort_list[j]

j -= increment

sort_list[j + increment] = sentry

def heap_adjust(sort_list, s, m):

''' (list, int, int) -> none

s is the last nonterminal node. m is the last node. This is going to build

a max heap.

'''

temp = sort_list[s]

# j is the index of s's left child

j = 2 * s + 1

while (j <= m):

# find the biggest one between her children

if j < m and sort_list[j] < sort_list[j + 1]:

j += 1

if temp >= sort_list[j]:

break

sort_list[s] = sort_list[j]

s = j

j = 2 * j + 1

sort_list[s] = temp

def heap_sort(sort_list):

iter_len = len(sort_list)

# make sort_list a max heap

for i in range(iter_len // 2 - 1, -1, -1):

heap_adjust(sort_list, i, iter_len - 1)

for i in range(iter_len - 1, 0, -1):

sort_list[0], sort_list[i] = sort_list[i], sort_list[0]

heap_adjust(sort_list, 0, i - 1)

def partition(sort_list, low, high):

''' (list, int, int) -> int

Sort the sort_list into two parts and return the pivot index of sort_list

'''

# find the midian of three

## m = low + (high - low) // 2

## if sort_list[low] > sort_list[high]:

## sort_list[low], sort_list[high] = sort_list[high], sort_list[low]

## if sort_list[m] > sort_list[high]:

## sort_list[m], sort_list[high] = sort_list[high], sort_list[m]

## if sort_list[m] > sort_list[low]:

## sort_list[low], sort_list[m] = sort_list[m], sort_list[low]

pivot = sort_list[low]

while low < high:

while low < high and sort_list[high] >= pivot:

high -= 1

sort_list[low] = sort_list[high]

while low < high and sort_list[low] <= pivot:

low += 1

sort_list[high] = sort_list[low]

sort_list[low] = pivot

return low

def q_sort(sort_list, low, high):

''' (list, int, int) -> None

'''

if low < high:

pivot = partition(sort_list, low, high)

q_sort(sort_list, low, pivot - 1)

q_sort(sort_list, low + 1, high)

def quick_sort(sort_list):

q_sort(sort_list, 0, len(sort_list) - 1)

# this short code snippets excerpted from python cookbook 2nd edithion, but it doesn't work well, I am gonna make it work.

##def quick_sort_2(sort_list):

## if len(sort_list) <= 1:

## return sort_list

## return quick_sort_2([lt for lt in sort_list[1:] if lt < sort_list[0]]) + sort_list[0:1] + \

## quick_sort_2([ge for ge in sort_list[1:] if ge >= sort_list[0]])

# constants for merging sort

MAXSIZE = 1000

def m_sort(sr, tr1, s, t):

''' (list, list, int, int) -> None

The main part of the merge sort

'''

tr2 = []

for i in range(MAXSIZE):

tr2.append(0)

if s == t:

tr1[s] = sr[s]

else:

m = (s + t) // 2

m_sort(sr, tr2, s, m)

m_sort(sr, tr2, m + 1, t)

merge(tr2, tr1, s, m, t)

def merge(sr, tr, i, m, n):

''' (list, list, int, int) -> None

'''

j = m + 1

k = i

while i <= m and j <= n:

if sr[i] < sr[j]:

tr[k] = sr[i]

i += 1

else:

tr[k] = sr[j]

j += 1

k += 1

if i <= m:

for l in range(0, m - i + 1):

tr[k + l] = sr[i + l]

if j <= n:

for l in range(0, n - j + 1):

tr[k + l] = sr[j + l]

def merge_sort(sort_list):

m_sort(sort_list, sort_list, 0, len(sort_list) - 1)

# easy test

##lis = [50, 10, 90, 30, 70, 40, 80, 60, 20]

##merge_sort(lis)

##print(lis)

# read 'random_num.txt' from disk

import tkinter.filedialog

sort_filename = tkinter.filedialog.askopenfilename()

sort_file = open(sort_filename, 'r')

contents = sort_file.read()

sort_file.close()

sort_list = contents.split(' ')

for i in range(len(sort_list) - 1):

sort_list[i] = int(sort_list[i])

sort_list.pop()

# using the sorting algorithm

shell_sort(sort_list)

# write sorted file to disk.

to_filename = tkinter.filedialog.asksaveasfilename()

sorted_file = open(to_filename, 'w')

for num in sort_list:

sorted_file.write(str(num) + ' ')

sorted_file.close()