主元素问题

x称为一个长度为n的数组a的主元素，如果这个数组里面等于x的元素数目不少于n/2个。

例如，a={2,3,2,2,5,3,2,4,2}, x = 2就是主元素。给定包含n个元素的数组a，主元素问题就是判断数组a是否包含一个主元素x。

三方法实现：

方法一：求中位数，主元素肯定是中位数，否则该元素数量少于n/2则不是主元素:快速排序，然后确定中位数时间复杂度O(nlogn)

方法二：分治的思想：

    若T 中存在主元素，则将T 分为两部分后，T 的主元素也必为两部分中至少一部分的主元素，因此可用分治法。

将元素划分为两部分，递归地检查两部分有无主元素。算法如下：

a. 若T 只含一个元素，则此元素就是主元素，返回此数。

      b. 将T 分为两部分T1 和T2（二者元素个数相等或只差一个），分别递归调用此方法求其主元素m1 和m2。

      c. 若m1 和m2 都存在且相等，则这个数就是T 的主元素，返回此数。

d. 若m1 和m2 都存在且不等，则分别检查这两个数是否为T 的主元素，若有则返回此数，若无则返回空值。

e. 若m1 和m2 只有一个存在，则检查这个数是否为T 的主元素，若是则返回此数，若否就返回空值。

f. 若m1 和m2 都不存在，则T 无主元素，返回空值。

方法三：思路比较新颖,原理是如果一个数组中存在一个主元素（个数大于n/2），则同时删除两个不相等的值，这个主元素不会改变。
简单的说就一个大小为n数组中存在一个元素的个数大于n/2，则如果用这个数组中其他元素和该主元素进行抵消的话，最后剩下的一定是主元素，因为主元素个数最多。
该方法可以在O(n)的时间内找到主元素，十分高效。

方法一代码如下：

#include <stdio.h>

//求中位数的方法
int swap(int *a, int *b)
{
        int temp = 0;
        temp = *a; 
        *a = *b;
        *b = temp;
}

int partition(int *num, int start, int end)
{
        int x = num[end];
        int i = start-1;
        int j;
        for (j = start; j < end; j++) {
                if (num[j] <= x) {
                        i = i + 1;
                        swap(&num[i], &num[j]);
                }
        }
        swap(&num[i+1], &num[end]);
        return i+1;

}

void quicksort(int *num, int start, int end)
{
        if( start < end) {
                int mid = partition(num, start, end);
                quicksort(num, start, mid-1);
                quicksort(num, mid+1, end);
        }
}

int main()
{
        int i;
        int num1[]={2,8,7,1,3,5,6,4};
        int num[] = {2,3,1,2,2,2,5,4,2,2};
        quicksort(num, 0, 7);
        for (i = 0; i < 8; i++) {
                printf("%d\n", num[i]);
        }
        int index = 9/2; //奇数n/2偶数n/2-1
        if (num[0] == num[index] || num[9] == num[index]) {
                printf("main element exits: index = %d element = %d\n", index, num[index]);
        }
        else {
                printf("main element not exits\n");
        }
}

方法二代码如下：

#include <stdio.h>
#include <stdlib.h>

typedef struct _node{
        int data;
        int count;
}*node;

int checkNum(int *num, int p, int q, int data)
{
        int count = 0;
        int i;
        for (i = p-1; i < q; i++) {
                if (num[i] == data) {
                        count++;
                }
        }
        return count;
}

node checkAnotherPart(int *num, int len, int p, int q, node nodec)
{
        nodec->count = checkNum(num, p, q, nodec->data) + nodec->count;
        if (nodec->count >= len/2) {
                return nodec;
        }
        else {
                return NULL;
        }
}
node checkMaster(int *num, int p, int q)
{
        node nodetmp = malloc(sizeof(node));
        node nodea = malloc(sizeof(node)); 
        node nodeb = malloc(sizeof(node));
        if (p == q) {
                nodetmp->data = num[p-1];
                nodetmp->count = 1;
                return nodetmp;
        }
        int len = q - p + 1;
        int mid = p + len / 2;
        nodea = checkMaster(num, p, mid-1);
        nodeb = checkMaster(num, mid, q);
        if (nodea == NULL && nodeb == NULL) {
                return NULL;
        }
        if (nodea == NULL && nodeb != NULL) {
                return checkAnotherPart(num, len, p, mid-1, nodeb);
        }
        if (nodea != NULL && nodeb == NULL) {
                return checkAnotherPart(num, len, mid, q, nodea);
        }
        if (nodea != NULL && nodeb != NULL) {
                if (nodea->data == nodeb->data) {
                        nodea->count = nodea->count + nodeb->count;
                        return nodea;
                }
                else {
                        node nodec = checkAnotherPart(num, len, p, mid-1, nodeb); 
                        if (nodec != NULL) {
                                return nodec;
                        }
                        else {
                                return checkAnotherPart(num, len, mid, q, nodea);
                        }
                }
        }

}

int main()
{

        int num[] = {2,2,3,1,2,2,2,5,4,2,2};
        node masterNode = checkMaster(num, 1, 11);
        printf("num = %d count = %d\n", masterNode->data, masterNode->count);
}

方法三代码如下：

#include <stdio.h>

int mainElement(int *num, int n)
{
        int seed = num[0];
        int count = 1;
        int i;
        for (i = 1; i < n; i++) {
               if (seed == num[i]) {
                       count++;
               }
               else {
                       if (count > 0) {
                               count--;
                       }
                       else {
                               seed = num[i];
                       }
               }
                
        }
        count = 0;
        for (i = 0; i < n; i++) {
                if (num[i] == seed) {
                        count++;
                }
        }
        if (count >= n/2) {
                return seed;
        }
        return 0; 
}

int main()
{
        int num1[]={2,8,7,1,3,5,6,4};
        int num[] = {2,3,1,2,2,2,5,4,2,2};
        int mainElem = mainElement(num, 8);
        if (mainElem != 0) 
                printf("main element is %d\n", mainElem);
        else 
                printf("main element not exits\n");

}