我正在尝试设计一种算法来查找数组中两个相同元素的索引。输入是一个数组,输出是两个索引i&j,使得arrayi=arrayj。时间复杂度必须为O(nlogn)。
这是我尝试过的
let i=0 to size_of_array{
let j=i+1 to size_of_array{
if array[j]=array[i]{
print(i, j)
}
}
}
嵌套循环是O(n^2),但如果我尝试这样设计。时间复杂度是多少?
N是数组的大小,我的实现将运行O(n(n-1)+(n-2)+(n-3)....+1)次。它
我有两个输入数组X和Y,我想返回数组X中出现频率最高的元素。
一种简单的方法是,对于数组X的每个元素X,我线性地搜索数组Y的出现次数,然后返回出现频率最高的元素x。下面是伪算法:
max_frequency = 0
max_x = -1 // -1 indicates no element found
For each x in X
frequency = 0
For each y in Y
if y == x
frequency++
End For
If frequency &g
根据从给定数组中查找所有可能的子数组的实现,如下所示:
public class AllPossibleSubArray {
public static void main(String[] args) {
int[] arr = { 1, 2, 3 };
List<List<Integer>> result = new ArrayList<>();
for (int len = 0; len <= arr.length; len++) {
if (len == 0)
有一个问题要求返回数组元素的所有唯一三重奏,这些元素加起来等于零(交换两个元素在三胞胎中的位置不算唯一)。
我想出了以下代码:
function threeSum(nums) {
nums.sort((a, b) => a - b);
const result = [];
for (let i = 0; i < nums.length; i++) {
// skipping duplicates
if (i !== 0 && nums[i] === nums[i - 1]) continue;
let left = i + 1
目标是创建一个接受两个参数的函数:整数数组和我们的目标整数数组,函数应该返回与目标相加的数组元素的两个索引。我们不能用它本身来和元素,我们应该假设给定的数组总是包含和回答
我使用一个for循环和一个while循环解决了这个代码kata练习。当N是阵列的总元素时,for循环的时间复杂度是线性的O(N),但对于每一个元素,过程帽子也是线性增加的。
这是否意味着该代码的总时间复杂度为O(N 2)?
public int[] twoSum(int[] nums, int target) {
int[] answer = new int[2];
for (int i =
我的职能如下:
function myFunction(array, sum){
for(var i = 0; i < array.length; i++){
var firstValue = array[i];
for(var x = i + 1; x < array.length; x++){
var secondValue = array[x];
if((firstValue + secondValue) == sum){
我有一个对象数组,我有两个堆栈,我遍历该数组,对于每个elemment,我将之前的对象推入(从堆栈1中弹出并推送到堆栈2),然后重新存储它们(从stack2中弹出并推送到堆栈1)。
我想知道复数是什么时候- o(n)或o(n^2)
因为每个堆栈操作(压入/弹出)都是o(1)。
for (int i = 0; i < buildingsHeight.Length; i++)
{
while (!BuildingStack.IsEmpty() && !didWeFoundHigerBuildi
(不是家庭作业)
我有一个包含重复元素的列表:A B C B A D C B
我想要每两个无序元素之间的最短距离:
(A B): 1
(A C): 2
(A D): 1
(B C): 1
(B D): 2
(C D): 1
我能否提高我当前实现的复杂性?元素是单词,搜索空间是段落,所以我期望长度为200的列表中有100个唯一的元素。
我的实施:
pairs <= map(pair, distance)
For each unique element 'me'
1. \ For each index 'o' of me in list
2.
比方说,我正在尝试寻找数组中最大的元素,并且我编写了一些代码,如下所示。
public class LargestElement
{
public static void main(String[] args)
{
int[] a = {1,2,6,4,5,4,3,1};
int max = a[0];
for(int i = 1;i<a.length;i++)
{
if(a[i] > max)
max = a[i];
}
目前,我有一个非常大的数组,我希望从其中得到最上面的n项,比排序数组所需的速度更快。从概念上讲,我非常肯定,无论JS解释器使用什么排序算法,都有可能胜过它。
下面是我目前使用的代码,它按照第二个元素对元组数组进行排序,然后返回前100个元组。元组中的第一项是标签,因此所需的输出是值最高的前100项。
// Sort the array based on the second element
items.sort(function(first, second) {
return second[1] - first[1];
});
// Create a new array with o