as the worst case scenario is stack push and pop each element in nums2[] once, and we have to loop through every element in nums1[] for the result, hence I think it's O(2*nums2.length + nums1.length) = O(nums1.length+nums2.length)
I thought that i could do it without the stack, going through the array from 1 to n-1 but with the decreasing case at the end you made me realize that i can't. Thank you
It is a bad idea to modify nums1. If a function returns an array you don't expect the input array to be modified. It also makes the code less readable;
what if array is ar1=[1,2,3,4] ar2=[1,4,2,3] stack [1]-> 4 comes , hashmap becomes ->(1,4) stack[4]-> 2 comes , False stack[4,2]-> 3 comes False Final answer -> [4,-1,-,1,-1] expected -[4,3,-1,-1] for this condition your code is not working? let me know if i am understanding your code wrong-> else solution.
@@sumansumann8947 worst case if u keep inserting elements in stack. After inserting last element in stack.. for is done no more.... It's linear. Analyze on paper.
Hey Nick I know its 4 years sice the upload can you still help me solve this can't figure out whats the mistake in this public int[] nextGreaterElement(int[] nums1, int[] nums2) { HashMap mp = new HashMap(); int p = -1; // int[] reversedNums2 = Arrays.copyOf(nums2, nums2.length); // reverseArray(reversedNums2); mp.put(nums2[nums2.length -1],-1); int max = nums2[nums2.length-1]; for(int i = nums2.length-2; i>=0; i--){ int current= nums2[i]; if(current < max){ if(i!=nums2.length && nums2[i+1] > current) max = nums2[i+1]; mp.put(current,max ); } else mp.put(current,-1); max = Math.max(current,max); } int[] res = new int [nums1.length]; for(int i =0; i< nums1.length; i++){ res[i] = mp.get(nums1[i]); } return res; }
It would be cool if you could discuss time and space complexity.
Could you possibly discuss runtime as you go through these
+1
@@LuisMorales-yx8di +1000 -1000
as the worst case scenario is stack push and pop each element in nums2[] once, and we have to loop through every element in nums1[] for the result, hence I think it's O(2*nums2.length + nums1.length) = O(nums1.length+nums2.length)
I thought that i could do it without the stack, going through the array from 1 to n-1 but with the decreasing case at the end you made me realize that i can't.
Thank you
public static int[] nextGreaterElement(int[] nums1, int[] nums2) {
int[] nextGreaterElements = new int[nums1.length];
int nextGreaterElement = -1;
for (int k = 0; k < nums1.length; ++k) {
nextGreaterElement = -1;
for (int i = 0; i < nums2.length; ++i) {
if (nums2[i] == nums1[k]) {
for (int j = i + 1; j < nums2.length; ++j) {
if (nums2[j] > nums1[k]) {
nextGreaterElement = nums2[j];
break;
}
}
break;
}
}
nextGreaterElements[k] = nextGreaterElement;
}
return nextGreaterElements;
}
the stack is an array with some constraints literally you can implement the stack using array but here we are using the concept of the stack
We should traverse from the backside of the nums2 array for more intuitive approach
sir how to get this level approach for doing such types of question?
Practice
Thanks a lot, sir
may you discuss the time and space complexity please, I find it hard to come up with it myself
Your explanation is just wow!
there is a bug : if there are some duplicted numbers in the array, then the value of key in the hasMap will be overwrited.
It's guranteed that there's no duplicates
Thanks for your explanation!
It is a bad idea to modify nums1. If a function returns an array you don't expect the input array to be modified. It also makes the code less readable;
what if array is ar1=[1,2,3,4] ar2=[1,4,2,3]
stack [1]-> 4 comes , hashmap becomes ->(1,4)
stack[4]-> 2 comes , False
stack[4,2]-> 3 comes False
Final answer -> [4,-1,-,1,-1]
expected -[4,3,-1,-1]
for this condition your code is not working?
let me know if i am understanding your code wrong-> else solution.
Instead of Peek you should stack last element
Can anyone help me with the time complexity of the nested loops in the given solution?
I love your humor Nick
great explanation! Thank yoU!
Very good explanation thanks
great explanation dude!!
You are just a Legend
I don't like hit me up 😂 good explanation
Brooooo! Awesome explaination .❤
what's the time complexity?
O(nums1.length + nums2.length) ~ O(m+n)
@@iamnoob7593 as there is a while loop inside the first for loop ,, how it would be linear time complexity??
@@sumansumann8947 worst case if u keep inserting elements in stack. After inserting last element in stack.. for is done no more.... It's linear.
Analyze on paper.
great explanation
This is beautiful
explain nge2 leet code solution
amazing explanation! Thank you!
Your runtime complexity here is O(N^2 ), right?
nope.
watch Abdul Bari videos about time complexity on youtube
Hey Nick I know its 4 years sice the upload can you still help me solve this can't figure out whats the mistake in this
public int[] nextGreaterElement(int[] nums1, int[] nums2) {
HashMap mp = new HashMap();
int p = -1;
// int[] reversedNums2 = Arrays.copyOf(nums2, nums2.length);
// reverseArray(reversedNums2);
mp.put(nums2[nums2.length -1],-1);
int max = nums2[nums2.length-1];
for(int i = nums2.length-2; i>=0; i--){
int current= nums2[i];
if(current < max){
if(i!=nums2.length && nums2[i+1] > current) max = nums2[i+1];
mp.put(current,max );
}
else mp.put(current,-1);
max = Math.max(current,max);
}
int[] res = new int [nums1.length];
for(int i =0; i< nums1.length; i++){
res[i] = mp.get(nums1[i]);
}
return res;
}
Why did you reverse the array
@@whoami8247 that line has been commented plz look closely