hxx/javascript-algorithms
1
0
Fork 0
mirror of https://github.moeyy.xyz/https://github.com/trekhleb/javascript-algorithms.git synced 2024-11-13 06:23:00 +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];
}
/* 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,
assuming that each number n is a rectangle of 1 width and n height. (Problem and solution taken from Leetcode #11)
/* 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
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) {
// 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.
area = (Math.min(height[left], height[right]) * (right - left));
area = (Math.min(unsortedArray[left], unsortedArray[right]) * (right - left));
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++;
} else {
area = (Math.min(height[left], height[right]) * (right - left));
area = (Math.min(unsortedArray[left], unsortedArray[right]) * (right - left));
mostArea = Math.max(area, mostArea);
right--;
}
}
// Our greatest area should be correct since we re-state if the current area is greater.
return mostArea
}