Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Finding Occurrence of a Number More Than N/2 Times in a Sorted Array in Java
In Java, there may be instances when we need to determine whether a specific number occurs more than half of the time in a sorted array. This article explores different approaches to solve this problem efficiently. We will discuss the syntax and provide detailed explanations for each approach. By the conclusion, you will clearly grasp how to use Java to identify a number that appears more than N/2 times in a sorted array.
Syntax
Let's start by examining the syntax employed for the algorithms described in this article −
public class Main {
public static int findMajorityElement(int[] nums) {
// Your code here
}
public static void main(String[] args) {
int[] nums = { /* Initialize your sorted array here */ };
int majorityElement = findMajorityElement(nums);
System.out.println("Majority Element: " + majorityElement);
}
}
Explanation of Syntax
We define a public class named Main.
Inside the Main class, we declare a public static method findMajorityElement that takes an integer array nums as its parameter. This method will return the majority element if it exists; otherwise, it will return -1.
In the main method, we initialize a sorted array named nums.
We call the findMajorityElement method, passing nums as an argument, and store the result in the majorityElement variable.
Finally, we print the majority element, if found, using System.out.println().
Approach 1
Algorithm
Initialize a variable count as 1 and majorityElement as nums[0].
Start at list 1 and emphasize over the entire exhibit.
Assuming the ongoing component matches the majorityElement, increment the count by one; in any case, drop the count by one. If count becomes 0, assign the current element as majorityElement and set count to 1.
Finally, return majorityElement as the result.
Example
public class Main {
public static int findMajorityElement(int[] nums) {
int count = 1;
int majorityElement = nums[0];
for (int i = 1; i < nums.length; i++) {
if (nums[i] == majorityElement)
count++;
else
count--;
if (count == 0) {
majorityElement = nums[i];
count = 1;
}
}
return majorityElement;
}
public static void main(String[] args) {
int[] nums = {2, 2, 2, 3, 4, 2, 2}; // Example array initialization
int majorityElement = findMajorityElement(nums);
System.out.println("Majority Element: " + majorityElement);
}
}
Output
Majority Element: 2
Explanation of Code in Approach 1
The code starts by initializing count as 1 and majorityElement as the first element of the array. Then, it iterates through the array from the second element onwards. For each element, it checks if it is equal to majorityElement. If so, it increments count; otherwise, it decrements count. This approach takes advantage of the fact that the majority element will occur more than N/2 times.
If count becomes 0, it means the previous element is no longer a candidate for the majority element. In this case, we update majorityElement to the current element and reset count to 1. At the end of the iteration, we return the majorityElement as the result.
Approach 2
Algorithm
Initialize a variable midIndex as nums.length / 2.
Iterate through the array from index 0 to midIndex - 1.
Check if the element at the current index is equal to the element at index midIndex.
Return the element that makes up the majority if the elements are equal.
Return -1 if the first half of the array contains no majority entry.
Example
public class Main {
public static int findMajorityElement(int[] nums) {
int midIndex = nums.length / 2;
for (int i = 0; i < midIndex; i++) {
if (nums[i] == nums[midIndex])
return nums[i];
}
return -1;
}
public static void main(String[] args) {
int[] nums = { /* Initialize your sorted array here */ };
int majorityElement = findMajorityElement(nums);
System.out.println("Majority Element: " + majorityElement);
}
}
Output
Majority Element: -1
Explanation of Code in Approach 2
In this method, the array is split into two equal parts, and each member in the first half is compared to the middle element (nums[midIndex]). The element is returned as the majority element if a match is found. We return -1, which denotes that there is no majority element, if there is no match in the first half.
Approach 3
Algorithm
Iterate through the array from index 0 to nums.length - 1.
Check if the element at the current index is equal to the element at index nums.length / 2.
Initialize a variable count as 0.
If the elements are equal, increment count by 1.
If count is greater than nums.length / 2, return the element as the majority element.
If no majority element is found, return -1.
Example
public class Main {
public static int findMajorityElement(int[] nums) {
int midIndex = nums.length / 2;
int majorityElement = nums[midIndex];
int count = 0;
for (int i = 0; i < nums.length; i++) {
if (nums[i] == majorityElement)
count++;
if (count > midIndex)
return majorityElement;
}
return -1;
}
public static void main(String[] args) {
int[] nums = {2, 2, 2, 3, 4, 2, 2}; // Example array initialization
int majorityElement = findMajorityElement(nums);
System.out.println("Majority Element: " + majorityElement);
}
}
Output
Majority Element: -1
Explanation of Code in Approach 3
In this approach, we iterate through the entire array and keep track of the count of the element at nums.length / 2. If the count exceeds nums.length / 2, we return the element as the majority element. If no majority element is found, we return -1.
Approach 4
Algorithm
Initialize a variable candidate as nums[0] and count as 1.
Iterate through the array from index 1 to nums.length - 1.
If the current element is equal to candidate, increment count by 1.
If the current element is different from the candidate, decrement count by 1.
If count becomes 0, update the candidate to the current element and set count to 1.
After the iteration, iterate through the array again and count the occurrences of candidates.
If the count is greater than nums.length / 2, return candidate as the majority element; otherwise, return -1.
Example
public class Main {
public static int findMajorityElement(int[] nums) {
int candidate = nums[0];
int count = 1;
for (int i = 1; i < nums.length; i++) {
if (nums[i] == candidate)
count++;
else
count--;
if (count == 0) {
candidate = nums[i];
count = 1;
}
}
count = 0;
for (int num : nums) {
if (num == candidate)
count++;
}
if (count > nums.length / 2)
return candidate;
else
return -1;
}
public static void main(String[] args) {
int[] nums = {2, 2, 2, 3, 4, 2, 2}; // Example array initialization
int majorityElement = findMajorityElement(nums);
System.out.println("Majority Element: " + majorityElement);
}
}
Output
Majority Element: 2
Explanation of Code in Approach 4
This approach follows the Boyer-Moore Voting Algorithm. Each time the array is iterated over, a candidate element is kept with a count of 1. The count is decreased each time a new element is encountered. A new candidate is chosen if the count is zero. After the iteration, we iterate through the array again to count the occurrences of the candidate. If the count exceeds nums.length / 2, we return the candidate as the majority element; otherwise, we return -1.
Conclusion
In this article, we explored four different approaches to finding the occurrence of a number more than N/2 times in a sorted array using Java. Each strategy offers a special resolution with varied degrees of effectiveness. You now possess the skills to approach this issue successfully in your Java projects by comprehending the algorithms, looking at the ready-to-run code, and paying attention to the step-by-step instructions.
140 Views
