From 45b35b363c9a5a7e1f63cf139864e809dcb6561c Mon Sep 17 00:00:00 2001 From: JeevaRamanathan Date: Wed, 2 Oct 2024 23:52:27 +0530 Subject: [PATCH 1/3] Improve comments in next_greatest_element.py Signed-off-by: JeevaRamanathan --- .../stacks/next_greater_element.py | 60 +++++++++++++++---- 1 file changed, 47 insertions(+), 13 deletions(-) diff --git a/data_structures/stacks/next_greater_element.py b/data_structures/stacks/next_greater_element.py index 7d76d1f47dfa..32c2dfc74535 100644 --- a/data_structures/stacks/next_greater_element.py +++ b/data_structures/stacks/next_greater_element.py @@ -6,9 +6,20 @@ def next_greatest_element_slow(arr: list[float]) -> list[float]: """ - Get the Next Greatest Element (NGE) for all elements in a list. - Maximum element present after the current one which is also greater than the - current one. + Get the Next Greatest Element (NGE) for each element in the array + by checking all subsequent elements to find the next greater one. + + This is a brute-force implementation, and it has a time complexity + of O(n^2), where n is the size of the array. + + Args: + arr (list[float]): List of numbers for which the NGE is calculated. + + Returns: + list[float]: List containing the next greatest elements. If no + greater element is found, -1 is placed in the result. + + Example: >>> next_greatest_element_slow(arr) == expect True """ @@ -28,8 +39,22 @@ def next_greatest_element_slow(arr: list[float]) -> list[float]: def next_greatest_element_fast(arr: list[float]) -> list[float]: """ - Like next_greatest_element_slow() but changes the loops to use - enumerate() instead of range(len()) for the outer loop and + Find the Next Greatest Element (NGE) for each element in the array + using a more readable approach This implementation utilizes + enumerate() for the outer loop and slicing for the inner loop. + + While this improves readability over next_greatest_element_slow(), + it still has a time complexity of O(n^2). + + Args: + arr (list[float]): List of numbers for which the NGE is calculated. + + Returns: + list[float]: List containing the next greatest elements. If no + greater element is found, -1 is placed in the result. + + Example: + for in a slice of arr for the inner loop. >>> next_greatest_element_fast(arr) == expect True @@ -47,14 +72,23 @@ def next_greatest_element_fast(arr: list[float]) -> list[float]: def next_greatest_element(arr: list[float]) -> list[float]: """ - Get the Next Greatest Element (NGE) for all elements in a list. - Maximum element present after the current one which is also greater than the - current one. - - A naive way to solve this is to take two loops and check for the next bigger - number but that will make the time complexity as O(n^2). The better way to solve - this would be to use a stack to keep track of maximum number giving a linear time - solution. + Efficient solution to find the Next Greatest Element (NGE) for all elements + using a stack. The time complexity is reduced to O(n), making it suitable + for larger arrays. + + The stack keeps track of elements for which the next greater element hasn't + been found yet. By iterating through the array in reverse (from the last + element to the first), the stack is used to efficiently determine the next + greatest element for each element. + + Args: + arr (list[float]): List of numbers for which the NGE is calculated. + + Returns: + list[float]: List containing the next greatest elements. If no + greater element is found, -1 is placed in the result. + + Example: >>> next_greatest_element(arr) == expect True """ From 7e905ad17b61e3c46791f15f9ea72217d7a07966 Mon Sep 17 00:00:00 2001 From: JeevaRamanathan Date: Thu, 3 Oct 2024 00:04:02 +0530 Subject: [PATCH 2/3] few changes Signed-off-by: JeevaRamanathan --- data_structures/stacks/next_greater_element.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/data_structures/stacks/next_greater_element.py b/data_structures/stacks/next_greater_element.py index 32c2dfc74535..8e104f3ca16d 100644 --- a/data_structures/stacks/next_greater_element.py +++ b/data_structures/stacks/next_greater_element.py @@ -40,7 +40,7 @@ def next_greatest_element_slow(arr: list[float]) -> list[float]: def next_greatest_element_fast(arr: list[float]) -> list[float]: """ Find the Next Greatest Element (NGE) for each element in the array - using a more readable approach This implementation utilizes + using a more readable approach. This implementation utilizes enumerate() for the outer loop and slicing for the inner loop. While this improves readability over next_greatest_element_slow(), @@ -54,8 +54,6 @@ def next_greatest_element_fast(arr: list[float]) -> list[float]: greater element is found, -1 is placed in the result. Example: - - for in a slice of arr for the inner loop. >>> next_greatest_element_fast(arr) == expect True """ From 3a1cdd90b99161ae1998bee2ea93462757efb860 Mon Sep 17 00:00:00 2001 From: JeevaRamanathan Date: Thu, 3 Oct 2024 05:44:03 +0530 Subject: [PATCH 3/3] updated descriptions of the functions parameters Signed-off-by: JeevaRamanathan --- data_structures/stacks/next_greater_element.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/data_structures/stacks/next_greater_element.py b/data_structures/stacks/next_greater_element.py index 8e104f3ca16d..216850b4b894 100644 --- a/data_structures/stacks/next_greater_element.py +++ b/data_structures/stacks/next_greater_element.py @@ -13,10 +13,10 @@ def next_greatest_element_slow(arr: list[float]) -> list[float]: of O(n^2), where n is the size of the array. Args: - arr (list[float]): List of numbers for which the NGE is calculated. + arr: List of numbers for which the NGE is calculated. Returns: - list[float]: List containing the next greatest elements. If no + List containing the next greatest elements. If no greater element is found, -1 is placed in the result. Example: @@ -47,10 +47,10 @@ def next_greatest_element_fast(arr: list[float]) -> list[float]: it still has a time complexity of O(n^2). Args: - arr (list[float]): List of numbers for which the NGE is calculated. + arr: List of numbers for which the NGE is calculated. Returns: - list[float]: List containing the next greatest elements. If no + List containing the next greatest elements. If no greater element is found, -1 is placed in the result. Example: @@ -80,10 +80,10 @@ def next_greatest_element(arr: list[float]) -> list[float]: greatest element for each element. Args: - arr (list[float]): List of numbers for which the NGE is calculated. + arr: List of numbers for which the NGE is calculated. Returns: - list[float]: List containing the next greatest elements. If no + List containing the next greatest elements. If no greater element is found, -1 is placed in the result. Example: