算法导论 python代码 第二章

<pre name="code" class="python"># author Ttssxuan

# this is the sample of the selection sort

def selection_sort(arr):
'''selection sort.
arr: the arr you want to sort'''
# find the ith element of the arr
for i in range(0, len(arr) - 1):
min = i
# find the min element in rest
for j in range(i + 1, len(arr)):
if arr[j] < arr[min]:
min = j
#swap the ith element to the ith position
temp = arr[min]
arr[min] = arr[i]
arr[i] = temp
#test
arr = [2, 4, 5, 9, 4]
selection_sort(arr)
print(str(arr))

# author Ttssxuan

# Insertion sort, sort the arr with ascent order

def insertion_sort(arr):
'''Insertion_sort, arr: the input arr that we want to sort'''
# scan every element of the arr and find the properly place for it
for j in range(1, len(arr)):
key = arr[j]
i = j - 1
# scan the sorted subarray arr[0..j -1], find the proper place
while(i >= 0 and key < arr[i]):
arr[i + 1] = arr[i]
i = i - 1
arr[i + 1] = key

# test
arr = [6, 2, 3, 4, 5]
insertion_sort(arr)
print(str(arr))

# author Ttssxuan
# Chapter 2

# merge sort, the provide two kinds of method to merge the two sequece.

from math import floor

def Merge(arr, p, q, e):
'''The merge, arr:the array need to merge, p:the start place of the first
part, q:the end of the first part, e:the end of the sencond merge part.
This is the version of with sentinel.'''
n1 = q - p + 1
n2 = e - q
l = [0] * (n1 + 1)
r = [0] * (n2 + 1)
# copy the first part from the initial arr
for i in range(0, n1):
l[i] = arr[p + i]
# copy the second part from the initial arr
for j in range(0, n2):
r[j] = arr[q + j + 1]
# set the sentinel of the two part
l[n1] = 10000
r[n2] = 10000
i = 0
j = 0
# merge the two part to arr
for k in range(p, e):
if l[i] <= r[j]:
arr[k] = l[i]
i += 1
else:
arr[k] = r[j]
j += 1

def Merge_no_sentinel(arr, p, q, e):
'''The merge, arr:the array need to merge, p:the start place of the first
part, q:the end of the first part, e:the end of the sencond merge part.
This is the version of without sentinel'''
n1 = q - p + 1
n2 = e - q
l = [0] * n1
r = [0] * n2
# copy the first part from the initail arr
for i in range(0, n1):
l[i] = arr[p + i]
# copy the second pary from the initail arr
for j in range(0, n2):
r[j] = arr[q + j + 1]

i = 0
j = 0
# merge the two part until one of the two part encount the end
for k in range(p, e + 1):
if (i < n1 and j < n2):
if l[i] <= r[j]:
arr[k] = l[i]
i += 1
else:
arr[k] = r[j]
j += 1
else:
break
# copy the rest of the two part to the initail arr
if i < n1:
while k <= e:
arr[k] = l[i]
k += 1
i += 1
if j < n2:
while k <= e:
arr[k] = r[j]
k += 1
j += 1

def Merge_sort(arr, s, e):
'''Use merge sort algorithm to sort the arr, and the start position is s,
the end position is e.'''
if s != e:
# get the middle of the arr for s to e
mid = int(floor((s + e) / 2))
# merge sort the first part
Merge_sort(arr, s, mid)
# merge sort the second part
Merge_sort(arr, mid + 1, e)
# merge the tow part
Merge_no_sentinel(arr, s, mid, e)

#test
arr = [1, 3, 5, 2, 4, 6]
Merge_sort(arr, 0, len(arr) - 1)
print(str(arr))

# author Ttssxuan
# 2.3-5
# binary search

import math

def binary_search(arr, value, s, e):
'''arr:input, value:the value you wanted, s: start place in the arr, e:the
end place in the arr
if no such value RETURN -1, else RETURN the place of the value'''
if s > e:
return -1
else:
# get the middle of the index
mid = int(math.floor((s + e) / 2))
# judge the mid is equal the value
if arr[mid] == value:
return mid
# search the first half
elif arr[mid] > value:
return binary_search(arr, value, s, mid - 1)
# search the second half
else:
return binary_search(arr, value, mid + 1, e)

# test
arr = [1, 2, 3, 4, 5]
place = binary_search(arr, 1, 0, len(arr) - 1)
if place != -1:
print("the place is ", place)
else:
print("no such value")

# author Ttssxuan
# 2.3-7
# Describe a ‚.n lg n/-time algorithm that, given a set S of n integers
# and another integer x, determines whether or not there exist two
# elements in S whose sum is exactly x.

from math import floor
import math

def Merge_no_sentinel(arr, p, q, e):
'''The merge, arr:the array need to merge, p:the start place of the first
part, q:the end of the first part, e:the end of the sencond merge part.
This is the version of without sentinel'''
n1 = q - p + 1
n2 = e - q
l = [0] * n1
r = [0] * n2
# copy the first part from the initail arr
for i in range(0, n1):
l[i] = arr[p + i]
# copy the second pary from the initail arr
for j in range(0, n2):
r[j] = arr[q + j + 1]

i = 0
j = 0
# merge the two part until one of the two part encount the end
for k in range(p, e + 1):
if (i < n1 and j < n2):
if l[i] <= r[j]:
arr[k] = l[i]
i += 1
else:
arr[k] = r[j]
j += 1
else:
break
# copy the rest of the two part to the initail arr
if i < n1:
while k <= e:
arr[k] = l[i]
k += 1
i += 1
if j < n2:
while k <= e:
arr[k] = r[j]
k += 1
j += 1

def Merge_sort(arr, s, e):
'''Use merge sort algorithm to sort the arr, and the start position is s,
the end position is e.'''
if s != e:
# get the middle of the arr for s to e
mid = int(math.floor((s + e) / 2))
# merge sort the first part
Merge_sort(arr, s, mid)
# merge sort the second part
Merge_sort(arr, mid + 1, e)
# merge the tow part
Merge_no_sentinel(arr, s, mid, e)

def binary_search(arr, value, s, e):
'''arr:input, value:the value you wanted, s: start place in the arr, e:the
end place in the arr
if no such value RETURN -1, else RETURN the place of the value'''
if s > e:
return -1
else:
mid = int(math.floor((s + e) / 2))
if arr[mid] == value:
return mid
elif arr[mid] > value:
return binary_search(arr, value, s, mid - 1)
else:
return binary_search(arr, value, mid + 1, e)

def estimate(arr, value):
'''arr: the set which you want to search, value: the value you want to
search.
Return [first, second], if get the place, the first and second present
the place of the two value, else return [-1, -1]'''
# sort the array first
Merge_sort(arr, 0, len(arr) - 1)
# search each element of the arr
for first in range(0, len(arr)):
# calculate the other of the two
rest = value - arr[first]
# use binary search verify if there is the value
second = binary_search(arr, rest, first + 1, len(arr) - 1)

if second != -1:
return [first, second]
return [-1, -1]

# test
arr = [1, 3, 4, 5]
print(arr)
result = estimate(arr, 10)
print(result)
result = estimate(arr, 4)
print(result)
result = estimate(arr, -1)
print(result)

# author Ttssxuan
# Problem 2-2
# bubblesort

def bubble_sort(arr):
# total rearrange len(arr) times
for i in range(0, len(arr) - 1):
# swap the min of the arr[i, len(arr) - 1] to the top
for j in range(len(arr) - 1, i, -1):
if arr[j] < arr[j - 1]:
# swap arr[j], arr[j - 1]
arr[j], arr[j - 1] = arr[j - 1], arr[j]

# test
arr = [9, 2, 5, 2, 0, 2]
bubble_sort(arr)
print(arr)

# author Ttssxuan
# Problem 2-4 d

# Give an algorithm that determines the number of inversions in any permutation
# on n elements in ‚.n lg n/ worst-case time.
# We implement it by modifying merge sort

from math import floor

def Merge_no_sentinel(arr, p, q, e):
'''The merge, arr:the array need to merge, p:the start place of the first
part, q:the end of the first part, e:the end of the sencond merge part.
This is the version of without sentinel
return the inversion number of this merge'''
n1 = q - p + 1
n2 = e - q
l = [0] * n1
r = [0] * n2

# copy the first part from the initail arr
for i in range(0, n1):
l[i] = arr[p + i]
# copy the second pary from the initail arr
for j in range(0, n2):
r[j] = arr[q + j + 1]

# recorder the total number of inversion
inversion_number = 0
# recorder the number of the numbers in array "r" which was added in "arr"
count = 0
i = 0
j = 0
# Merge the two part until one of the two part encount the end.
# We know that if the number in ther array "l" less than the number in the
# array "r", the pair of the number is not inversion, so we just count the
# number in array "r" which added in the "arr" before the number in array
# "l". Each this occur, we know there is inversion.
for k in range(p, e + 1):
if (i < n1 and j < n2):
if l[i] <= r[j]:
arr[k] = l[i]
i += 1
# add the inversion for this number
inversion_number += count
else:
arr[k] = r[j]
j += 1
# increase the number which was added in "arr"
count += 1
else:
break
# copy the rest of the two part to the initail arr
if j < n2:
while k <= e:
arr[k] = r[j]
k += 1
j += 1
if i < n1:
while k <= e:
arr[k] = l[i]
k += 1
i += 1
# add the inversion for this number
inversion_number += count
return inversion_number

def Merge_sort(arr, s, e):
'''Use merge sort algorithm to sort the arr, and the start position is s,
the end position is e.
return the inversion number of the arr'''
inversion_number = 0
if s != e:
# get the middle of the arr for s to e
mid = int(floor((s + e) / 2))
# merge sort the first part
inversion_number += Merge_sort(arr, s, mid)
# merge sort the second part
inversion_number += Merge_sort(arr, mid + 1, e)
# merge the tow part
inversion_number += Merge_no_sentinel(arr, s, mid, e)
return inversion_number

def count_inversion(arr):
'''count the inversion number of a sequence, which was implement by change
the merge sort
arr: the sequence we want to count
return the inversion number of the sequence.'''
return Merge_sort(arr, 0, len(arr) - 1)

#test
arr = [1, 2, 0, -1]
re = count_inversion(arr)
print re
arr = [0, 1, 2, 3]
re = count_inversion(arr)
print re
arr = [5, 4, 3, 2, 1]
re = count_inversion(arr)
print re