Loop invariant of linear search

As seen on Introduction to Algorithms (http://mitpress.mit.edu/algorithms), the exercise states the following:

Input: Array A[1...n]

Output: i, where A[i]=v or NIL when not found

Write a pseudocode for LINEAR-SEARCH, which scans through the sequence, looking for v. Using a loop invariant, prove that your algorithm is correct. (Make sure that your loop invariant fulﬁlls the three necessary properties – initialization, maintenance, termination.)

I have no problem creating the algorithm, but what I don't get is how can I decide what's my loop invariant. I think I understood the concept of loop invariant, that is, a condition that is always true before the beginning of the loop, at the end/beginning of each iteration and still true when the loop ends. This is usually the goal, so for example, at insertion sort, itearting over j, starting at j=2, the [1, j-1] elements are always sorted. This makes sense for me. But for a linear search? I can't think of anything, it just sounds too simple to think of a loop invariant. Did I understand something wrong? I can only think of something obvious like (it's either NIL or between 0 and n). Thanks a lot in advance!

After you have looked at index i, and not found v yet, what can you say about v with regard to the part of the array before i and with regard to the part of the array after i?

In the case of linear search, the loop variant will be the backing store used for saving the index(output) .

Lets name the backing store as index which is initially set to NIL.The loop variant should be in accordance with three conditions :

Initialization : This condition holds true for index variable.since, it contains NIL which could be a result outcome and true before the first iteration.
Maintenance : index will hold NIL until the item v is located. It is also true before the iteration and after the next iteration.As, it will be set inside the loop after comparison condition succeeds.
Termination : index will contain NIL or the array index of the item v.

Loop invariant would be

forevery 0 <= i < k, where k is the current value of the loop iteration variable, A[i] != v

On loop termination:

if A[k] == v, then the loop terminates and outputs k

if A[k] != v, and k + 1 == n (size of list) then loop terminates with value nil

Proof of Correctness: left as an exercise

LINEAR-SEARCH(A, ν)
1  for i = 1 to A.length
2      if A[i] == ν 
3          return i
4  return NIL

Loop invariant: at the start of the ith iteration of the for loop (lines 1–4),

∀ k ∈ [1, i) A[k] ≠ ν.

Initialization:

i == 1 ⟹ [1, i) == Ø ⟹ ∀ k ∈ Ø A[k] ≠ ν,

which is true, as any statement regarding the empty set is true (vacuous truth).

Maintenance: let's suppose the loop invariant is true at the start of the ith iteration of the for loop. If A[i] == ν, the current iteration is the final one (see the termination section), as line 3 is executed; otherwise, if A[i] ≠ ν, we have

∀ k ∈ [1, i) A[k] ≠ ν and A[i] ≠ ν ⟺ ∀ k ∈ [1, i+1) A[k] ≠ ν,

which means that the invariant loop will still be true at the start of the next iteration (the i+1th).

Termination: the for loop may end for two reasons:

return i (line 3), if A[i] == ν;
i == A.length + 1 (last test of the for loop), in which case we are at the beginning of the A.length + 1th iteration, therefore the loop invariant is
```
∀ k ∈ [1, A.length + 1) A[k] ≠ ν ⟺ ∀ k ∈ [1, A.length] A[k] ≠ ν
```
and the NIL value is returned (line 4).

In both cases, LINEAR-SEARCH ends as expected.

Assume that you have an array of length i, indexed from [0...i-1], and the algorithm is checking if v is present in this array. I'm not totally sure, but I think, the loop invariant is as follows: If j is the index of v, then [0..j-1] will be an array that does not have v.

Initialization : Before iterating from 0..i-1, the current array checked (none), does not consist of v.

Maintenance : On finding v at j, array from [0..j-1] will be an array without v.

Termination : As the loop terminates on finding v at j, [0..j-1] will be an array without j.

If the array itself does not have v, then j = i-1, and the above conditions will still hold true.

The invariant for linear search is that every element before i is not equal to the search key. A reasonable invariant for binary search might be for a range [low, high), every element before low is less than the key and every element after high is greater or equal. Note that there are a few variations of binary search with slightly different invariants and properties - this is the invariant for a "lower bound" binary search which returns the lowest index of any element equal to or greater than the key.

Source:https://www.reddit.com/r/compsci/comments/wvyvs/what_is_a_loop_invariant_for_linear_search/

Seems correct to me.

The LS algorithm that I wrote is-

LINEARSEARCH(A, v)
  for i=0 to A.length-1
    if(A[i] == v)
      return i
  return NIL

I made my own assumptions for loop invariant for checking correctness of Linear Search..... Maybe its totally wrong so I need suggestions on my assumptions.

1) At Initialisation- at i = 0, we are searching for v at i = 0.

2) At successive iterations- we are looking for v till i < A.length-1

3) At termination- i = A.length and till A.length we kept looking for v.

来源：https://stackoverflow.com/questions/5585020/loop-invariant-of-linear-search

标签

algorithm

invariants

loop-invariant