TADM2E 4.11 - Revision history

Matt: Undo revision 1057 by FuckMatt (talk)

2020-08-01T01:05:36Z

Undo revision 1057 by FuckMatt (talk)

FuckMatt: Blanked the page

2020-07-31T09:35:52Z

Blanked the page

FTange at 11:24, 11 June 2017

2017-06-11T11:24:36Z

Algowikiadmin: Recovering wiki

2014-09-11T18:22:46Z

Recovering wiki

Algowikiadmin: Recovering wiki

2014-09-11T18:13:28Z

Recovering wiki

New page

Note that there can be at most one element which appears more than n/2 (i.e. at least ceil(n/2) ) times in the list.

If we now consider the *sorted* version of the list, we'll see that if such an element exists, it covers
a consecutive range in the list. The start of this range can be at various places with the extreme
cases being:

* the range starts at element 1
* the range ends at element n

We can easily see that in both cases (and therefore also in the cases between the extremes) that if there
is an element which appears more than n/2 times, the element at position ceil(n/2) (in the sorted list) must have this value.

This leads to the following algorithm:

Determine the ceil(n/2) smallest element of the (unsorted) set. The [http://en.wikipedia.org/wiki/Selection_algorithm#Linear_general_selection_algorithm_-_Median_of_Medians_algorithm BFPRT] algorithm can do that in O(n) running time in the worst case .

Go through the list element by element and count the number of occurrences of this ceil(n/2) smallest element.
If it occurs at more than n/2 times, this is the element we were looking for, otherwise the list does not contain such an element.

----
Alternatively, successively remove pairs of distinct elements from the list. If there is an element that appears more than n/2 times, it won't have a pair eventually. The algorithm below removes pairs of distinct elements from the list until the residual list (maybe empty) contains only equal elements. If the residual list is non-empty, its head is a candidate for the element that appears more than n/2 times. Whether it is so can be checked in one linear sweep. If the residual list is empty, the list doesn't contain an element that appears more than n/2 times.

The algorithm works as follows. We traverse the list recursively and maintain an additional stack. The stack is initially empty. If both the list and stack are non-empty, then either the top of the stack is distinct from the head of the list, in which case they both can be removed, or they are equal, in which case we move the head of the list to the top of the stack, thus maintaining the invariant that the stack contains only equal elements. If the stack becomes empty, but there are still elements in the list, we move the head of the list onto the stack. If the list becomes empty, the stack contains elements for which there was no pair. We can implement this algorithm in Haskell as follows:

candidates :: Eq a => [a] -> [a]
candidates = go []
where
go ys [] = ys
go [] (x:xs) = go [x] xs
go (y:ys) (x:xs)
| y == x = go (x:y:ys) xs
| y /= x = go ys xs

← Older revision		Revision as of 09:35, 31 July 2020
Line 1:		Line 1:
−	~~Note that there can be at most one element which appears more than n/2 (i.e. at least ceil(n/2) ) times in the list.~~

−	~~If we now consider the sorted version of the list, we'll see that if such an element exists, it covers~~
−	~~a consecutive range in the list. The start of this range can be at various places with the extreme~~
−	~~cases being:~~
−
−	* the range starts at element 1
−	* the range ends at element n
−
−	~~We can easily see that in both cases (and therefore also in the cases between the extremes) that if there~~
−	~~is an element which appears more than n/2 times, the element at position ceil(n/2) (in the sorted list) must have this value.~~
−
−	~~This leads to the following algorithm:~~
−
−	Determine the ceil(n/2) smallest element of the (unsorted) set. The [http://en.wikipedia.org/wiki/Selection_algorithm#Linear_general_selection_algorithm_-_Median_of_Medians_algorithm BFPRT] algorithm can do that in O(n) running time in the worst case .
−
−	~~Go through the list element by element and count the number of occurrences of this ceil(n/2) smallest element.~~
−	~~If it occurs at more than n/2 times, this is the element we were looking for, otherwise the list does not contain such an element.~~
−
−	~~----~~
−	Alternatively, successively remove pairs of distinct elements from the list. If there is an element that appears more than n/2 times, it won't have a pair eventually. The algorithm below removes pairs of distinct elements from the list until the residual list (maybe empty) contains only equal elements. If the residual list is non-empty, its head is a candidate for the element that appears more than n/2 times. Whether it is so can be checked in one linear sweep. If the residual list is empty, the list doesn't contain an element that appears more than n/2 times.
−
−	The algorithm works as follows. We traverse the list recursively and maintain an additional stack. The stack is initially empty. If both the list and stack are non-empty, then either the top of the stack is distinct from the head of the list, in which case they both can be removed, or they are equal, in which case we move the head of the list to the top of the stack, thus maintaining the invariant that the stack contains only equal elements. If the stack becomes empty, but there are still elements in the list, we move the head of the list onto the stack. If the list becomes empty, the stack contains elements for which there was no pair. We can implement this algorithm in Haskell as follows:
−
−	~~candidates :: Eq a => [a] -> [a]~~
−	~~candidates = go []~~
−	~~where~~
−	~~go ys [] = ys~~
−	~~go [] (x:xs) = go [x] xs~~
−	~~go (y:ys) (x:xs)~~
−	~~\| y == x = go (x:y:ys) xs~~
−	~~\| y /= x = go ys xs~~
−
−	~~----~~
−	~~== Algorithm for any arbitrary number of occurences ==~~
−	For each element insert it into a dictionary. If the element is not in the dictionary add it with a count of one, if it is already in the dictionary increment its value. This can be done in linear time and space if using something like a hash function.
−	Each time we change the count of an element we check if its frequency exceeds the number we are looking for. If it does we either save it or return it, depending on whether we want to find one or all such elements.

← Older revision		Revision as of 11:24, 11 June 2017
Line 31:		Line 31:
	\| y == x = go (x:y:ys) xs		\| y == x = go (x:y:ys) xs
	\| y /= x = go ys xs		\| y /= x = go ys xs
		+
		+	----
		+	== Algorithm for any arbitrary number of occurences ==
		+	For each element insert it into a dictionary. If the element is not in the dictionary add it with a count of one, if it is already in the dictionary increment its value. This can be done in linear time and space if using something like a hash function.
		+	Each time we change the count of an element we check if its frequency exceeds the number we are looking for. If it does we either save it or return it, depending on whether we want to find one or all such elements.

← Older revision	Revision as of 01:05, 1 August 2020
Line 1:	Line 1:
	+	Note that there can be at most one element which appears more than n/2 (i.e. at least ceil(n/2) ) times in the list.

	+	If we now consider the sorted version of the list, we'll see that if such an element exists, it covers
	+	a consecutive range in the list. The start of this range can be at various places with the extreme
	+	cases being:
	+
	+	* the range starts at element 1
	+	* the range ends at element n
	+
	+	We can easily see that in both cases (and therefore also in the cases between the extremes) that if there
	+	is an element which appears more than n/2 times, the element at position ceil(n/2) (in the sorted list) must have this value.
	+
	+	This leads to the following algorithm:
	+
	+	Determine the ceil(n/2) smallest element of the (unsorted) set. The [http://en.wikipedia.org/wiki/Selection_algorithm#Linear_general_selection_algorithm_-_Median_of_Medians_algorithm BFPRT] algorithm can do that in O(n) running time in the worst case .
	+
	+	Go through the list element by element and count the number of occurrences of this ceil(n/2) smallest element.
	+	If it occurs at more than n/2 times, this is the element we were looking for, otherwise the list does not contain such an element.
	+
	+	----
	+	Alternatively, successively remove pairs of distinct elements from the list. If there is an element that appears more than n/2 times, it won't have a pair eventually. The algorithm below removes pairs of distinct elements from the list until the residual list (maybe empty) contains only equal elements. If the residual list is non-empty, its head is a candidate for the element that appears more than n/2 times. Whether it is so can be checked in one linear sweep. If the residual list is empty, the list doesn't contain an element that appears more than n/2 times.
	+
	+	The algorithm works as follows. We traverse the list recursively and maintain an additional stack. The stack is initially empty. If both the list and stack are non-empty, then either the top of the stack is distinct from the head of the list, in which case they both can be removed, or they are equal, in which case we move the head of the list to the top of the stack, thus maintaining the invariant that the stack contains only equal elements. If the stack becomes empty, but there are still elements in the list, we move the head of the list onto the stack. If the list becomes empty, the stack contains elements for which there was no pair. We can implement this algorithm in Haskell as follows:
	+
	+	candidates :: Eq a => [a] -> [a]
	+	candidates = go []
	+	where
	+	go ys [] = ys
	+	go [] (x:xs) = go [x] xs
	+	go (y:ys) (x:xs)
	+	\| y == x = go (x:y:ys) xs
	+	\| y /= x = go ys xs
	+
	+	----
	+	== Algorithm for any arbitrary number of occurences ==
	+	For each element insert it into a dictionary. If the element is not in the dictionary add it with a count of one, if it is already in the dictionary increment its value. This can be done in linear time and space if using something like a hash function.
	+	Each time we change the count of an element we check if its frequency exceeds the number we are looking for. If it does we either save it or return it, depending on whether we want to find one or all such elements.

@@ Line 23: / Line 23: @@
 The algorithm works as follows.  We traverse the list recursively and maintain an additional stack.  The stack is initially empty.  If both the list and stack are non-empty, then either the top of the stack is distinct from the head of the list, in which case they both can be removed, or they are equal, in which case we move the head of the list to the top of the stack, thus maintaining the invariant that the stack contains only equal elements.  If the stack becomes empty, but there are still elements in the list, we move the head of the list onto the stack.  If the list becomes empty, the stack contains elements for which there was no pair.  We can implement this algorithm in Haskell as follows:
-     candidates :: Eq a =&gt; [a] -&gt; [a]
+     candidates :: Eq a => [a] -> [a]
      candidates = go []
          where