python寻找多数元素_寻找多数元素

今天实现的算法是寻找多数元素，多数元素是指在一个含有n个元素的序列中出现次数多于[n/2](向下取整)的元素。

蛮力寻找多数元素是对每个元素进行计数，如果某个元素的计数超过[n/2]，则断言它是多数元素，否则不存在多数元素。这种方法的时间复杂度过高，可以寻找更高性能的算法解决这类问题。

如果一个序列存在多数元素，那么该多数元素一定是该序列排序后的中间元素，也就是第[n/2](向上取整)个元素。所以可以通过寻找一个序列的中间元素，然后判断该元素是否为多数元素来寻找多数元素。对于此方法，有一个结论可以使用：

在原序列中去除两个不同元素后，那么在原序列中的多数元素在新序列中还是多数元素。

这个结论可以支持一个寻找多数元素候选者的算法，该算法的伪代码如下：

算法：CANDIDATE

输入：n个元素的数组A[1...n]

输出：多数元素的候选元素

candidate(m)

j ← m

c ← A[m]

count ← 1

while j < n and count > 0:

j ← j + 1

if A[j] = c then

count = count + 1

else

count = count - 1

end if

end while

if j == n then return c

else return candidate(j+1)

在寻找到候选多数元素后，只需要对该元素进行计数，判断是否为多数元素，该算法伪代码如下：

算法：MAJORITY

输入：n个元素的数组A[1...n]

输出：若存在多数元素，则输出；否则输出none

c ← candidate(1)

count ← 0

for j ← 1 to n:

if A[j] == c then

count = count + 1

end if

end for

if count > [n/2] then return c

else return none

下面是三种代码的实现，首先是C++版本：

#include

#define Type int

#define NONE INT_MIN

using namespace std;

Type candidate(Type *a, int n, int m) {

int j = m;

Type c = a[m];

int count = 1;

while (j < n && count > 0) {

j ++;

if (a[j] == c) {

count ++;

}else {

count --;

}

}

if (j == n) {

return c;

}else {

return candidate(a, n, j+1);

}

}

//输入数组必须有n+1个元素，第0个元素不使用，元素为1..n

//若存在多数元素，则返回多数元素的值，若不存在则返回NONE

Type Majority(Type *a, int n) {

Type c = candidate(a, n, 1);

int count = 0;

for (int j = 1; j <= n; j ++) {

if (a[j] == c) {

count ++;

}

}

if (count > n/2) {

return c;

} else {

return NONE;

}

}

int main(void) {

Type a[14] = {0, 1, 2, 5, 5, 5, 4 ,3 ,2, 5, 5, 4, 5, 5};

cout << "输入数组为：\n";

for (int i = 1; i <= 13; i ++) {

cout << a[i] << " ";

}

cout << endl;

cout << "多数元素为：\n" << Majority(a, 13) << endl;

getchar();

return 0;

}

然后是Java代码：

import java.util.ArrayList;

public class MajorityList {

private ArrayList list = new ArrayList();

private boolean hasMajority = false;

private int majority_value = 0;

/**

* 构造函数，使list从第1个元素开始保存，而不是第0个

*/

public MajorityList() {

list.add(0);

}

/**

* 寻找候选者

* @param m

* @return 返回可能的多数元素

*/

private int candidate(int m) {

int j = m;

int c = list.get(m);

int count = 1;

while (j < list.size()-1 && count > 0) {

j ++;

if (list.get(j) == c) {

count ++;

}else {

count --;

}

}

if (j == list.size()-1) {

return c;

}else {

return candidate(j+1);

}

}

/**

* 判断候选者是否为多数元素

*/

private void majority() {

int c = candidate(1);

int count = 0;

for (int j = 1; j <= list.size()-1; j ++) {

if (list.get(j) == c) {

count ++;

}

}

if (count > (list.size()-1)/2) {

hasMajority = true;

majority_value = c;

} else {

hasMajority = false;

majority_value = 0;

}

}

public void add(int x) {

list.add(x);

hasMajority = false;

majority_value = 0;

}

public boolean hasMajorityElement() {

majority();

return hasMajority;

}

public int getMajorityElement() {

return majority_value;

}

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

int [] a = {1, 2, 5, 5, 5, 4 ,3 ,2, 5, 5, 4, 5, 5};

MajorityList ml = new MajorityList();

System.out.println("输入数组为：");

for (int i = 0; i < a.length; i++) {

System.out.print(a[i]);

System.out.print(" ");

ml.add(a[i]);

}

System.out.println();

boolean result = ml.hasMajorityElement();

System.out.print("是否存在多数元素？ ");

System.out.println(result);

if (result) {

System.out.print("多数元素为：");

System.out.println(ml.getMajorityElement());

}

}

}

最后是Python实现：

#! /usr/bin/env python

# -*- coding:utf-8 -*-

class MajorityList:

def __init__(self):

self._list = list()

self.hasMajority = False

self.majority_value = 0

self._list.append(0)

def candidate(self, m):

j = m

c = self._list[m]

count = 1

while j < len(self._list)-1 and count > 0:

j = j + 1

if self._list[j] == c:

count += 1

else:

count -= 1

if j == len(self._list)-1:

return c

else:

return self.candidate(j+1)

def majority(self):

c = self.candidate(1)

count = 0

for j in range(1, len(self._list)):

if self._list[j] == c:

count += 1

if count > (len(self._list)-1)/2:

self.hasMajority = True

self.majority_value = c

else:

self.hasMajority = False

self.majority_value = 0

def add(self, x):

self._list.append(x)

self.hasMajority = False

self.majority_value = 0

def hasMajorityElement(self):

self.majority()

return self.hasMajority

def getMajorityElement(self):

return self.majority_value

if __name__ == '__main__':

a = [1, 2, 5, 5, 5, 4 ,3 ,2, 5, 5, 4, 5, 5]

ml = MajorityList()

print '输入数组为：'

for i in a:

print i,

ml.add(i)

print

result = ml.hasMajorityElement()

print '是否存在多数元素？', result

if result:

print '多数元素为：', ml.getMajorityElement()

分享到：

2012-03-09 16:17

浏览 1520

评论