hxx/javascript-algorithms
1
0
Fork 0
mirror of https://github.moeyy.xyz/https://github.com/trekhleb/javascript-algorithms.git synced 2024-11-14 06:52:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

finishing twin pointer functions

Browse Source
This commit is contained in:
Francis Yang 2024-01-09 08:10:31 -08:00
parent 44f3b4cc2f
commit 17d38b4815
1 changed files with 12 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/algorithms/search/twin-pointers/twinPointers.js
View File

@ -41,8 +41,8 @@ export function twinPointerSorted(sortedArray, seekElement, comparatorCallback)
return [0, 0]; return [0, 0];
} }
/* An example of a twin pointer method on an unsorted array. In this problem, we aim to get the heighest possible area from two numbers, /* An example of a twin pointer method on an unsorted array. In this problem, we aim to get the heighest possible area from two numbers by using the
assuming that each number n is a rectangle of 1 width and n height. (Problem and solution taken from Leetcode #11) small of the two heights, assuming that each number n is a rectangle of 1 width and n height. (Problem and solution taken from Leetcode #11)
*/ */
/** /**
@ -67,22 +67,28 @@ export function twinPointerUnsorted(unsortedArray, comparatorCallback) {
while (left !== right) { while (left !== right) {
// In this situation, since we don't have a specific "target" in mind we instead compare the two values at our two pointers to each other. // In this situation, since we don't have a specific "target" in mind we instead compare the two values at our two pointers to each other.
if (height[left] < height[right]) { if (comparator.lessThan(unsortedArray[left], unsortedArray[right])) {
// Here we simply calculate our current area and whether we need to change our highest area by comparing it with the current. // Here we simply calculate our current area and whether we need to change our highest area by comparing it with the current.
area = (Math.min(height[left], height[right]) * (right - left)); area = (Math.min(unsortedArray[left], unsortedArray[right]) * (right - left));
mostArea = Math.max(area, mostArea); mostArea = Math.max(area, mostArea);
/** /**
* Again, we move the left pointer forward or the right pointer backwards. You may be thinking that * Again, we move the left pointer forward or the right pointer backwards. You may be thinking that this is basically the same as with the
* sorted array; while that is correct from a pure code standpoint, conceptually the reasoning is different. In the first example, because the array
* is sorted we can move the left pointer forward with the knowledge that this will DEFINITELY either keep the value the same or increase it.
* In this situation however, our array isn't sorted and thus moving the left pointer forward isn't guaranteed to increase the value; all we know
* is that it will change. However, because we are calculating area with the smallest height and our value (heght) at the left pointer is smaller than the right pointer,
* we know that the ONLY way to get a higher area is if there is a potentially higher value for the left pointer.
*/ */
left++; left++;
} else { } else {
area = (Math.min(height[left], height[right]) * (right - left)); area = (Math.min(unsortedArray[left], unsortedArray[right]) * (right - left));
mostArea = Math.max(area, mostArea); mostArea = Math.max(area, mostArea);
right--; right--;
} }
} }
// Our greatest area should be correct since we re-state if the current area is greater.
return mostArea return mostArea
} }