Design and Analysis of Algorithms_Fundamentals of the Analysis of Algorithm Efficiency

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 SequentialSearch(A[..n-], k)
    // Searches for a given value in a given array by sequential search
    // Input: An array A[0..n-1] and a search key K
    // Output: The index of the first element of A that matches K or -1 if there are no matching elements
    i <-
    while i < n and A[i] ≠ K do
        i <- i+
    if i < n return i
    else return -

Algorithm MaxElement(A[..n-])
    // Determines the value of the largest element in a given array
    // Input: An array A[0..n-1] of real numbers
    // Output: The value of the largest element in A
    maxval <- A[]
    for i <-  to n- do
        if A[i] > maxval
            maxval <- A[i]
    return maxval

Algorithm UniqueElements(A[..n-])
    // Determines whether all the elements in a given array are distinct
    // Input: An array A[0..n-1]
    // Output: Returns "true" if all the elements in A are distinct and "false" otherwise
    for i <-  to n- do
        for j <- i+ to n- do
            if A[i] = A[j]
                return false
    return true

Given two n-by-n matrices A and B, we hava a definition-based algorithm for computer their product C = AB. By definition , C is an n-by-n matrix whose elements are computed as the scalar(dot) products of the rows of matrix A and the columns of matrix B: where C[i, j] = A[i, 0]B[0, j] + ... + A[i, k]B[k, j] + A[i, n-1]B[n-1, j] for every pair of indices 0 ≤ i, j ≤ n-1.
Algorithm MatrixMultiplication(A[0..n-1, 0..n-1], B[0..n-1, 0..n-1])
    // Multiplies two n-by-n matrices by the definition-based algorithm
    // Input: Two n-by-n matrices A and B
    // Output: Matrix C = AB
    for i <-  to n- do
        for j <-  to n- do
            C[i, j] <- 0.0
            for k <-  to n- do
                C[i, j] <- C[i, j] + A[i, k]*B[k, j]
    return C
Improve the implementation of the matrix multiplication algorithm by reduce the number of addtions made by the algorithm. What effect will this change hava on the algorithm's efficiency?
Replace the body of j loop by follwing fragment:
    C[i,j] <- A[i,]*B[,j]
    for k <-  to n- do
        C[i,j] <- C[i,j] + A[i,k]*B[k,j]
This will decrease the number of additions from n^3 to n^3-n^2, but the number of multiplications will still be n^3. The algorithm's efficiency class will remain cubic. 

The following algorithm finds the number of binary digits in the binary representation of a position decimal integer. The exact formula for the number of times the comparision n > 1 will be executed is actually ⌊log2n⌋ + 1
Algorithm Binary(n)
    // Input: A position decimal integer n
    // Output: The number of binary digits in n's binary representation
    count <-
    while n >  do
        count <- count +
        n <- ⌊n/⌋ 

Then we investigate a recursive version of the algorithm:
Algorithm BinRec(n)
    // Input: A positive decimal integer n
    // Output: The number of binary digits in n's binary representation
    if n =  return
    else return BinRec(⌊n/⌋) + 1
Algorithm Mystery(n)
    // Input: A nonnegative integer n
    S <-
    for i <-  to n do
        S <- S + i*i
    return S

Algorithm Secret(A[..n-])
    // Input: An array A[0..n-1] of n real numbers
    minval <- A[]; maxval <- A[]
    for i <-  to n- do
        if A[i] < minval
            minval <- A[i]
        if A[i] > maxval
            maxval <- A[i]
    return maxval - minval

The following algorithm return "true" if its input matrix is symmetric and "false" if it is not.
Algorithm Enigma(A[..n-, ..n-])
    // Input: A matrix A[0..n-1, 0..n-1] of real numbers
    for i <-  to n- do
        for j <- i+ to n- do
            if A[i,j] ≠ A[j,i]
                return false
    return true

Algorithm F(n)
    // Computers n! recursively
    // Input: A nonnegative integer n
    // Output: The value of n!
    if n =  return
    else return F(n-)*n

Consider the following recursive algorithm for computing the sum of the first n cubes:
Algorithm S(n)
    // Input: A positive integer n
    // Output: The sum of the first n cubes
    if n =  return
    else return S(n-) + n*n*n
Here is a pseudocode for the nonrecursive option:
Algorithm NonrecS(n)
    // Computes the sum of the first n cubes nonrecursively
    // Input: A positive integer n
    // Output: The sum of the first n cubes.
    S <-
    for i <-  to n do
        S <- S + i*i*i
    return S
The number of multiplications made both of this two algorithm will be 2(n-1), but the nonrecursive version doesn't carry the time and space overhead associated with the recursion's stack.

Algorithm Power(n)
    // Computes 2^n recursively by the formula 2^n = 2^(n-1) + 2^(n-1)
    // Input: A nonnegative integer n
    // Output: Returns 2^n
    if n =  return
    else return Power(n-) + Power(n-)

The following algorithm computes the value of the smallest element in a given array.
Algorithm Min1(A[..n-])
    // Input: An array A[0..n-1] of real numbers
    if n =  return A[]
    else temp <- Min1(A[..n-])
        if temp ≤ A[n-] return temp
        else return A[n-]
Consider another algorithm for solving the problem, which recursively divides an array into two halves: call Min2(A[0..n-1]) 
Algorithm Min2(A[l..r])
    if l = r return A[l]
    else
        temp1 <- Min2(A[l..⌊(l+r)/⌋]) 
        temp2 <- Min2(A[⌊(l+r)/⌋+..r])
        if temp1 ≤ temp2
            return temp1
        else
            return temp2
We can prove that both of them for the number of key comparisons is n-1.
A simple standard scan through the array in question requires the same number of key comparisons while avoiding the overhead associated with recursive calls. It is clear, however, that any algorithm for this problem must be in Ω(n).

Algorithm F(n)
    // Computes the nth Fibonacci number recursively by using its definition
    // Input: A nonnegative integer n
    // Output: The nth Fibonacci number
    if n ≤  return n
    else return F(n-) + F(n-)

Algorithm Fib(n)
    // Computes the nth Fibonacci number iteratively by using its definition
    // Input: A nonnegative integer n
    // Output: The nth Fibonacci number
    F[] <- ; F[] <-
    for i <-  to n do
        F[i] <- F[i-] + F[i-]
    return F[n]
Algorithm Fib2(n)
    // Computes the n-th Fibonacci number using just two variables
    // Input: A nonnegative integer n
    // Output: The n-th Fibonacci number
    u <- ; v <-
    for i <-  to n do
        v <- v + u
        u <- v - u
    if n =  return
    else return v

The following well-known sorting algorithm with a counter inserted to count the number of key comparisons.
Algorithm SortAnalysis(A[..n-])
    // Input: An array A[0..n-1] of n orderable elements
    // Output: The total number of key comparisons made
    count <-
    for i <-  to n- do
        v <- A[i]
        j <- i-
        while j ≥  and A[j] > v do
            count <- count+
            A[j+] <- A[j]
            j <- j-
        if j ≥  count <- count+
        A[j+] <- v
    return count

new words:
sequential: 顺序的 formula: 公式 symmetric: 对称的
cubic: 立方的 investigate: 调查;研究 halves: 两等份

(End_xpjiang).