I collect and make up this pseudocode from the book:
<<Introduction to the Design and Analysis of Algorithms_Second Edition>> _ Anany Levitin
Note that throughout the paper, we assume that inputs to algorithms fall within their specified ranges and hence require no verfication. When implementing algorithms as programs to be used in actual applications, you should provide such verfications.
About pseudocode: For the sake of simplicity, we omit declarations of variables and use indentation to show the scope of such statements as for, if and while. As you saw later, we use an arrow <- for the assignment operation and two slashes // for comments.
Algorithm SelectionSort(A[0..n-1])
// Sorts a given array by selection sort
// Input: An array A[0..n-1] of orderable elements
// Output: Array A[0..n-1] sorted in ascending order
for i <- 0 to n-2 do
min <- i
for j <- i+1 to n-1 do
if A[j] < A[min]
min <- j
swap A[i] and A[min]
Algorithm BubbleSort(A[0..n-1])
// Sorts a given array by bubble sort
// Input: An array A[0..n-1] of orderable elements
// Output: Array A[0..n-1] sorted in ascending order
for i <- 0 to n-2 do
for j <- 0 to n-2-i do
if A[j+1] < A[j]
swap A[j] and A[j+1]
Here is a pseudocode for the improved version of bubble sort:
Algorithm BetterBubbleSort(A[0..n-1])
// The algorithm sorts array A[0..n-1] by improved bubble sort
// Input: An array A[0..n-1] of orderable elements
// Output: Array A[0..n-1] sorted in ascending order
count <- n-1 // number of adjacent pairs to be compared
sflag <- true // swap flag
while sflage do
sflage <- false
for j <- 0 to count-1 do
if A[j+1] < A[j]
swap A[j] and A[j+1]
sflag <- true
count <- count-1
Here is a pseudocode of teh most straightforward version:
Algorithm BruteForcePolynomialEvaluation(P[0..n], x)
// The algorithm computes the value of polynomial P at a given point x by the
// "highest-to-lowest" brute-force algorithm
// Input: Array P[0..n] of the coefficients of a polynomial of degree n, stored from the lowest
// to the highest and a number x
// Output: The value of the polynomial at the point x
p <- 0.0
for i <- n downto 0 do
power <- 1
for j <- 1 to i do
power <- power*x
p <- p + P[i]*power
return p
We can count just the number of multiplications in the algorithm's inner-most loop to find the algorithm's efficiency class: M(n) = n(n+1)/2 = O(n^2)
The above algorithm is very inefficient: we recompute powers of x again and again as if there were no relationship among them. Thus, the obvious improvement is based on computing consecutive powers more efficiently:
Algorithm BetterBruteForcePolynomialEvaluation(P[0..n-1], x)
// The algorithm computes the value of polynomial P at a given point x by the
// "lowest-to-highest term" algorithm
// Input: Array P[0..n] of the coefficients of a polynomial of degree n, from the
// lowest to the highest, and a number x
// Output: The value of the polynomial at the point x
p <- P[0]; power <- 1
for i <- 1 to n do
power <- power*x
p <- p + P[i]*power
return p
The number of multiplications here is M(n) = 2n, in another word, we have a linear algorithm
Algorithm SequentialSearch2(A[0..n], K)
// Implements sequential search with a search key as a sentinel
// Input: An array A of n elements and a search key K
// Output: The index of the first element in A[0..n-1] whose value is equal
// to K or -1 if no such element if found
A[n] <- K
i <- 0
while A[i] ≠ K do
i <- i + 1
if i < n return i
else return -1
Algorithm BruteForceStringMatch(T[0..n-1], P[0..m-1])
// Implements brute-force string matching
// Input: An array T[0..n-1] of n characters representing a text and
// an array P[0..m-1] of m characters representing a pattern
// Output: The index of the first character in the text that starts a
// matching substring or -1 if the search is unsuccessful
for i <- 0 to n-m do
j <- 0
while j < m and P[j] = T[i+j] do
j <- j+1
if j = m return i
return -1
Algorithm BruteForceClosestPoints(P)
// Finds two closest points in the plane by burte force
// Input: A list P of n(n ≥ 2) points P1 = (x1, x2),...,Pn = (xn, yn)
// Output: Indices index1 and index2 of the closest pair of points
dmin <- ∞
for i <- 1 to n-1 do
for j <- i+1 to n do
d <- sqrt((xi-xj)2 + (yi-yj)2) // sqrt is the square root function. In fact, computing square roots can be avoided, the trick is to realize that we can simply ignore the square root function
if d < dmin
dmin <- d; index1 <- i; index2 <- j
return index1, index2
Let x1 < x2 < ... < xn be real numbers representing coordinates of n villages located along a straight road. A post office needs tobe built in one of these villages. Design an efficent algorithm to find the post offfice location minimizing the maximum distance from a village to the post office.
Assuming that the points x1, x2, ... xn are given in increasing order, the answer is the point xi that is the closest to m = (x1 + xn) / 2, the middle point between x1 and xn. (The middle point woule be the obvious solution if the post-post office didn't have tobe at one of the given locations.) Indeed, if we put the post office at any location xi to the left of m, the longest distance froma village to the post office would be xn - xi; this distance is minimal for the rightmost among such points. If we put the post office at any location xi to the right of m, the longest distance from a village to the post office would be xi - x1; this distance isminimal for the leftmost among such points.
Algorithm PostOffice(P)
// Input: List P of n(n ≥ 2) point s x1, x2,..., xn in increasing order
// Output: Point xi that minimizes max(1≤j≤n)|xj - xi| among all x1,x2,...,xn
m <- (x1+xn) / 2
i <- 1
while xi < m do
i <- i+1
if xi - x1 < xn - xi-1
return xi
else return xi-1
new words:
polynomial: 多项式 coefficient: 系数 inefficient: 低效的
sentinel: 哨兵 plane: 平面 coordinate: 坐标
village: 村庄 straight: 直; 直线
(END_XPJIANG)