我有一个包含三个元素的数组,如[31,23,12],我想找到第二大的元素及其相关位置,而不重新排列数组。
示例:
array = [21,23,34]
第二大的数为23;
它的位置是第1个。
我有一个包含三个元素的数组,如[31,23,12],我想找到第二大的元素及其相关位置,而不重新排列数组。
示例:
array = [21,23,34]
第二大的数为23;
它的位置是第1个。
使用 .slice(0)
创建原始数组的克隆,例如:
var temp_arr = arr.slice(0);
将数组排序,以便您在索引temp_arr.length - 2
处获得第二大的值:
temp_arr.sort()[temp_arr.length - 2]
indexOf()
函数来获取检索到的值的索引,例如:arr.indexOf(second_largest_value);
var arr = [23, 21, 34, 34];
var temp_arr = [...new Set(arr)].slice(0); //clone array
var second_largest_value = temp_arr.sort()[temp_arr.length - 2];
var index_of_largest_value = arr.indexOf(second_largest_value);
console.log(second_largest_value);
console.log(index_of_largest_value);
我在这里尽可能地简化了答案,你可以把它看作非常简单
function getSecondLargest(nums) {
var flarge = 0;
var slarge = 0;
for (var i = 0; i < nums.length; i++) {
if (flarge < nums[i]) {
slarge = flarge;
flarge = nums[i];
} else if (nums[i] > slarge) {
slarge = nums[i]
}
}
return slarge;
}
这是完全逻辑化的,这里没有数组排序或反转,当在数组中存在重复值时,你也可以使用这个方法。
使用 ES6 Set 和 Array.from
const secondLargest = (arr) => Array.from([...new Set(arr)]).sort((a,b) => b-a)[1]
上述函数使用 Set 删除重复元素,并返回排序后数组中的第二大元素。
function getSecondLargest(nums) {
nums.sort(function(x,y){
return y-x;
});
for(var j=1; j < nums.length; j++)
{
if(nums[j-1] !== nums[j])
{
return nums[j];
}
}
}
getSecondLargest([1,2,3,4,5,5]);
输出:4
这种方法还可以处理数组中一个数字的多次出现。在这里,我们首先对数组进行排序,然后忽略相同的数字并返回答案。
找到n个最大数的简单递归函数,而不需要重新排列数组:
编辑: 也适用于有多个相等的最大数的情况。
Original Answer: 最初的回答
let array = [11,23,34];
let secondlargest = Max(array, 2);
let index = array.indexOf(secondlargest);
console.log("Number:", secondlargest ,"at position", index);
function Max(arr, nth = 1, max = Infinity) {
let large = -Infinity;
for(e of arr) {
if(e > large && e < max ) {
large = e;
} else if (max == large) {
nth++;
}
}
if(nth==0) return max;
return Max(arr, nth-1, large);
}
var arr = [21,23,34];
var output = getSecondLargest(arr);
document.getElementById("output").innerHTML = output;
function getSecondLargest(nums) {
if (nums.length == 0){
return undefined;
}
nums.sort((a,b) => b-a);
var newArr = [...new Set(nums)];
return newArr[1];
}
<p id="output"></p>
function getSecondLargest(nums) {
const sortedArray = new Set(nums.sort((a, b) => b - a)).values();
sortedArray.next();
return sortedArray.next().value;
}
console.log(getSecondLargest([1, 2, 4, 4, 3]));
这段代码将会返回第二大的数及其索引
const a = [1, 2, 3, 4, 6, 7, 7, 8, 15]
a.sort((a,b)=>a-b) //sorted small to large
const max = Math.max(...a)
const index = a.indexOf(max)
const s = {secondLargest:a[index-1],index:index-1}
console.log(s)
spread
和 sort()
创建原始 array
的副本。然后,只需从数组中获取倒数第二个数字,并使用 indexOf
揭示其索引。
const array = [21,23,34];
const arrayCopy = [...array];
const secondLargestNum = arrayCopy.sort()[arrayCopy.length - 2]
console.log(array.indexOf(secondLargestNum));
如果兼容性是问题,您可以使用concat
复制数组:
var array = [21, 23, 34];
var arrayCopy = [].concat(array);
var secondLargestNum = arrayCopy.sort()[arrayCopy.length - 2]
console.log(array.indexOf(secondLargestNum));
这种方法最为冗长,但也是算法效率最高的。它只需要对原始数组进行一次遍历,不需要复制数组,也不需要排序。它还符合ES5标准,因为你问到了支持性。
var array = [21,23,34];
var res = array.reduce(function (results, curr, index) {
if (index === 0) {
results.largest = curr;
results.secondLargest = curr;
results.indexOfSecondLargest = 0;
results.indexOfLargest = 0;
}
else if (curr > results.secondLargest && curr <= results.largest) {
results.secondLargest = curr;
results.indexOfSecondLargest = index;
}
else if (curr > results.largest) {
results.secondLargest = results.largest;
results.largest = curr;
results.indexOfSecondLargest = results.indexOfLargest;
results.indexOfLargest = index;
}
return results;
}, {largest: -Infinity, secondLargest: -Infinity, indexOfLargest: -1, indexOfSecondLargest: -1});
console.log("Second Largest: ", res.secondLargest);
console.log("Index of Second Largest: ", res.indexOfSecondLargest);
slice
,sort
,indexOf
),并且不会同时返回数字和相应的索引。 - mhodges
https://dev59.com/Mafja4cB1Zd3GeqPuFWY#57360512
- Chang