IBM最後有道求主元素的題目，一個數組有N個元素，其中有超過N/2的元素相同，請找出這個元素。時間複雜度為O(n)
方法1：
如果一個元素的個數超過N/2則這個元素必然是這N個元素的中位數。則這個題目是找中位數。方法是通過快速排序變化的來的演算法。
程式碼如下：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

template<typename T>
void swap(T & a,T& b)
{
	T c = a;
	a = b;
	b = c;
}


/*
	partitions the array around the pivot. 

	elements in the the left part are all less than or equal to pivot while those in the right part are all greater than or equal to pivot.

	in this version of partition function, it can gurantee that the returned index is the index of pivot in the array.
	so if we want to use this version we should care about the returned index value and modify the qsort function to adapt it.
	
	@return the index of the most left element that is less than or equal to pivot.
*/

template<typename T>
int partition(T * array,int l,int r)
{
	if(l>=r)return l;
	int i = l;
	int j = r;
	int m = (l+r)/2;
	T pivot = array[m];

	while(i < j){
		while(i<j && array[i]<pivot){
			i++;
		}
		while(i<j && array[j]>pivot){
			--j;
		}

		if(i<j){
			swap(array[i],array[j]);
			++i;
			--j;		
		}
	}
	if(i == j && array[j]>pivot)
	{
		--j;
	}
	return j;
}
template<typename T>
void qsort(T * array,int l,int r)
{
	if(l>=r)return;
	int p = partition(array,l,r);
	qsort(array,l,p);
	qsort(array,p+1,r);
}
/*
find the kthSmallestElement in the array

in this function both version of partition function is ok

first step: partitions the array into two parts.

second step: count the number of elements in the left part

third step: if the number of elements is less than k, it means the kthSmallestElement is in the right part of the array.
	    if the number of elements is greater than or equal to k, it means the kthSmallestElement is in the left part.
	
*/
template<typename T>
T kmedian(T * array,int l, int r, int k)
{
	if(l>=r)return array[l];
	int p = partition(array,l,r);
	int i = p-l+1;//count of elements in the left part.
	if(i<k)return kmedian(array,p+1,r,k-i);
	return kmedian(array,l,p,k);
}


template<typename T>
T majorElement(T * array,int n)
{
	T ret = kmedian(array,0,n-1,n/2);
	return ret;
}
int main()
{
	int b[]={2,1,1,23,3,1,1,2};
	printf("%d",majorElement(b,8));
	printf("/n");
	return 0;
}
 
做這個題目複習了下快排，選擇一個pivot，然後圍繞這個pivot將陣列分成兩部分，左邊一部分的元素都小於pivot，右邊部分的元素都大於pivot，然後遞迴的處理左右兩個部分，直到陣列元素個數為1.找第k小元素的方法是基於快排的分割函式，將一個數組分割成兩部分。如果小於pivot的元素個數A小於k，則在分割後的陣列的右邊找第k-A小的元素，否則在左邊部分找。對於中位數就是第n/2小的數。根據演算法導論的說明，快排的平均演算法複雜度為O(nlogn)，而找第k小元素的平均演算法複雜度為O（n）。找k小的演算法和快排的不同在於快排需要遞迴處理左邊和右邊兩個部分，即複雜度方程為：        O(1)       n = 1 T(n)={        2T(n/2)   n> 1而對於求第k小數，只需要遞迴處理一個分支，所以複雜度方程為：        O(1)       n = 1T(n)={        T(n/2)     n> 1雖然只比快排少了個係數2，但是可以推匯出來求第k小數的複雜度為O(n),而快排為O（nlogn）方法2：求眾數的方法：
 
對於找主元素的題目，還有其他的做法，可以使用求眾數的方法，首先選擇一個pivot，然後將陣列分割成兩部分，左邊的小於pivot，右邊的大於pivot在分割過程中統計陣列中等於pivot的元素個數，小於pivot的元素個數以及大於pivot的元素個數。如果pivot的元素個數大於等於n/2，則pivot就是所求元素。如果小於pivot的元素個數大於等於n/2，則在左邊部分找，否在在右邊部分找。程式碼為：template<typename T>
T mode(T * array,int l,int r,int n)
{
        if(l>=r)return array[l];
        int i = l;
        int j = r;
        int m = (l+r)/2;
        int c = 0;
        T pivot = array[m];

        while(i < j){
                while(i<j && array[i]<pivot){
                        i++;
                }
                while(i<j && array[j]>pivot){
                        --j;
                }
                if(i<j){
                        if(array[i]==pivot)++c;
                        if(array[j]==pivot)++c;
                        swap(array[i],array[j]);
                        ++i;
                        --j;            
                }
        }
        if(i == j && array[j] == pivot)++c;
        if(i == j && array[j]>pivot)
        {
                --j;
        }
        if(c >= n/2)return pivot;
        if(j-l+1>=n/2)return mode(array,l,j,n);
        return mode(array,j+1,r,n);
}
 
在統計pivot出現次數時需要注意是在交換i，j對應元素時判斷的。因為只有當array[i]>=x並且array[j]<=x才需要交換元素。同時當退出While（i<j）時，需要判斷i==j&&Array[j]==pivot的情況，因為i==j的情況在while中是沒有處理的，所以必須在while外處理。當統計得到pivot的出現次數後可以進行遞迴。如pivot出現的次數大於等於n/2，則返回pivot，否在向元素個數大的那部分陣列遞迴。

方法3：主元素查詢：

關於這種主元素還有種更加巧妙地方法，沒看到過一定想不到的。這種方法的原理是如果一個數組中存在一個主元素（個數大於n/2），則同時刪除兩個不相等的值，這個主元素不會改變。
簡單的說就一個大小為n陣列中存在一個元素的個數大於n/2，則如果用這個陣列中其他元素和該主元素進行抵消的話，最後剩下的一定是主元素，因為主元素個數最多。
該方法可以在O(n)的時間內找到主元素，十分高效。
程式碼：
template<typename T> T mainElement(T * array, int n) { T seed = array[0]; int count = 1; for(int i = 1;i<n;++i) { if(seed == array[i]) { count++; } else{ if(count > 0)count--; else{ seed= array[i]; } } } count=0; for(int i = 0; i < n;++i) { if(array[i]==seed)++count; } if(count >=n/2)return seed; return -1; }

關鍵的演算法在找seed過程中，假設第一個元素是主元素，遍歷陣列，如果遇到和seed相同的元素則加1，不同則減1，如果count==0了，則seed改變。
該方法的基礎就是如果存在一個值是主元素，那麼遍歷一遍則出現的次數一定要大於其他所有元素的次數，所以最後主元素的count一定大於0.