如何证明伪代码有效？

如何解决如何证明伪代码有效？

忍受我；因为这是我第一次在stackoverflow上问一些问题。 我最近在“数据结构和算法简介”中进行了一次考试（可能失败了），并且正在尝试使之有意义。 问题之一，给出以下伪代码：

majority(A[1...n])
1.index <- 1
2.candidate <- NIL
3.counter <- 0
4.while index<=n
5.   do if counter = 0
6.       then candidate <- A[index]
7.            counter <- counter + 1
8.       else if candidate = A[index]
9.          then counter <- counter + 1
10.      else counter <- counter - 1
11.    index <- index + 1
12.return candidate

a。证明如果一个元素在数组中出现的次数超过n / 2次，则 算法将返回该值。 提示：每次计数器归零时，哪个语句保持为真？

如此直观，每次计数器归零时，保持为真的语句为 直到阵列中的这一点，我们都没有找到一个出现次数超过所有次数的元素 因此，如果元素出现的次数超过n / 2次，则其他元素组合在一起 然后再加上其他元素，最后我们将计数器> 0保留，并且大多数 元素是候选人。

但是，我不明白证明这一事实意味着什么。 我应该使用数学归纳法来证明这一点吗？

尝试数学归纳法

Induction hypothesis:
If an element e appears m times when m>n/2 then the code will return e.


Base case: n=3 => n/2=1 therefore m=2 or m=3.
if m=2 and array is (e,e,a) then counter->0->1->2->1 while candidate->NIL->e therefore e will be returned.
if m=2 and array is (e,a,e) then counter->0->1->0->1->0->1 while candidate->NIL->e->a->e therefore e will be returned.
if m=2 and array is (a,e) then counter->0->1->0->1->2 while candidate->NIL->a->e therefore e will be returned.
if m=3 array is (e,e) then counter->0->1->2->3 while candidate->NIL->e therefore e will be returned.

Assume induction hypothesis is true for array size n.
if array is size n+1 then element e appears m>(n+1)/2 times.
since m>n/2 then if we scan sub array A[1...n] then we would return e as per the induction hypothesis
meaning that after element A[n] we have candidate = e and counter>=1.
if counter>1 a[n+1] doesn't matter and we return e.

if counter=1 and a[n+1] is not e then we will not return e.
if counter=1 after sub-array A[1...n] then m=(n+1)/2...I will prove that later.
since m>((n+1)/2 we reached a contradiction and counter>1 necessarily.
Therefore for an array size n+1 and m>(n+1)/2 we will return e.
Thus ends the induction.

proving that if (candidate=e and counter=1 at the end of function) then m = (n+1)/2:
given an array A[1...n] lets name the number of elements which aren't e as k.
since m>n/2 then k<n/2.
since for each e element we get +1 to counter m contributes +m to counter.
since for each non e element we get -1 to counter k contributes -k to counter.
since we know that candidate=e and counter=1 then that means:
(m=k+1) => (k+1>n/2) => (k+1>n/2>k) => (2>n-2*k>0) => (n-2*k=1) => (k=(n-1)/2) => (m=k+1=(n+1)/2)
end of proof

这是我应该做的吗？ 这是一个15/100分的问题，这是预期目的还是 有没有更简单的方法来解决这个问题？ 我会很感激任何人都可以提供的帮助。

如果有人感兴趣，这是c中的代码：

#include <stdio.h>

int majority(int A[],int size);

int main()
{
    int A[9] = {1,2,3,1,3};
    int size = sizeof(A)/sizeof(A[0]);
    majority(A,size);

    return 0;
}

int majority(int A[],int size)
{
    int index = 0;
    int* candidate = NULL;
    int counter = 0;

    while(index < size)
    {
        if(counter == 0)
        {
            candidate = &(A[index]);
        }
        else if(*candidate == A[index])
        {
            counter++;
        }
        else
        {
            counter--;
        }
        index++;
    }
    printf("%d",*candidate);
    return 0;
}