算法设计与分析部分算法伪代码

第三章蛮力法

1.选择排序

⏹SelectionSort(A[0..n-1])

for i=0 to n-2 do

min=i

for j=i+1 to n-1 do

if A[j]

min=j

swap A[i] and A[min]

2.冒泡排序

⏹BubbleSort(A[0..n-1])

// 输入：数组A，数组中的元素属于某偏序集

// 输出：按升序排列的数组A

for i=0 to n-2 do

for j=0 to n-2-i do

if A[j+1]

3.改进的冒泡算法

⏹ALGORITHM BubbleSortImproved( A[0,…,n – 1] )

// 冒泡排序算法的改进

// 输入：数组A，数组中的元素属于某偏序集

// 输出：按升序排列的数组A

for i ←0 to n – 2 do

flag ←True

for j ←0 to n – 2 – i do

if A[j+1] < A[j]

swap(A[j], A[j+1])

flag ←False

// 如果在某一轮的比较中没有交换，则flag为True，算法结束

if flag = True return

4.顺序查找算法

算法SwquentialSearch2(A[0...n],k)

//顺序查找算法的实现，它用了查找键来作限位器

//输入：一个n个元素的数组A和一个查找键K

//输出：第一个值等于K的元素的位置，如果找不到这样的元素就返回-1

A[n]<--k

i<--0

while A[i]!=K do

i<--i+1

if i

Else return -1

5.蛮力字符串匹配

算法BruteForceStringMatch(T[0...n-1],P[0...m-1])

//该算法实现了蛮力字符串匹配

//输入：一个n个字符的数组T[0...n-1]代表一段文本

// 一个m个字符的数组P[0..m-1]代表一个模式

//输出：如果查找成功的话，返回文本的第一个匹配字串中第一个字符的位置，// 否则返回-1

For i<--0 to n-m do

j<--0

While j

j<--i+1

If j=m return i

return -1

⏹合并排序最差Θ(nlog2n)

⏹快速排序最优Θ(nlog2n)

最差Θ(n2)

平均Θ(1.38nlog2n)

⏹选择排序Θ(n2)

⏹冒泡排序Θ(n2)

⏹插入排序最差Θ(n2)

⏹最优Θ(n)

⏹平均Θ(n2)

第四章分治法

合并排序

算法MergeSort(A[0..n-1] )

// 递归调用mergesort来对数组A[0...n-1] 排序

// 输入：一个可排序数组A[0..n-1]

// 输出：非降序排列的数组A[0..n-1]

if n > 1

copy A[0..⎣n/2⎦-1] to B[0..⎣n/2⎦-1]

copy A[⎣n/2⎦..n-1] to C[0..⎣n/2⎦-1]

MergeSort( B )

MergeSort( C )

Merge( B,C,A )

两个数组合并的算法

算法Merge(B[0..p-1],C[0..q-1],A[0..p+q-1])

//将两个有序数组合并成一个有序的数组

//输入：两个有序数组B[0...p-1]和C[0...q-1]

//输出：A[0..p+q-1]中已经有序存放了B和C中的元素

i=0,j=0,k=0;

while i

if B[i]≤C[j]

A[k]=B[i], i=i+1

else

A[k]=C[j], j=j+1

k=k+1

if i=p

copy C[j..q-1] to A[k..p+q-1]

else

copy B[i..p-1] to A[0..p+q-1]

快速排序算法

QuickSort(A[l..r])

// 使用快速排序法对序列或者子序列排序

// 输入：子序列A[l..r]或者序列本身A[0..n-1]

// 输出：非递减序列A

if l < r

s ←Partition( A[l..r] )

QuickSort( A[l..s-1] )

QuickSort( A[s+1..r] )

//s是中轴元素/基准点，是数组分区位置的标志

实现分区的算法

Partition( A[l..r] )

// 输入：子数组A[l..r]

// 输出：分裂点/基准点pivot的位置

p ←A[l]i ←l; j ←r+1

repeat

repeat i ←i + 1until A[i] ≥p

repeat j ←j –1 until A[j] ≤p

swap( A[i], A[j] )

until i ≥j

swap( A[i], A[j] )

swap( A[l], A[j] )

return j

折半查找

BinarySearch( A[0..n-1], k )

// 输入：已排序大小为n的序列A，待搜索对象k

// 输出：如果搜索成功，则返回k的位置，否则返回-1 l=0,r=n-1;

While l≤r

mid= ⎣(l+r)/2⎦

if k = A[mid] return mid

else if k < A[mid] r=m-1

else l=m+1

return -1