下面是两个几乎相同的程序,除了我切换i和j变量.它们都运行在不同的时间.有人能解释为什么会这样吗？
版本1
#include <stdio.h>
#include <stdlib.h>
main () {
int i,j;
static int x[4000][4000];
for (i = 0; i < 4000; i++) {
for (j = 0; j < 4000; j++) {
x[j][i] = i + j; }
}
}
版本2
#include <stdio.h>
#include <stdlib.h>
main () {
int i,j;
static int x[4000][4000];
for (j = 0; j < 4000; j++) {
for (i = 0; i < 4000; i++) {
x[j][i] = i …几天前在Facebook上的演讲 - 幻灯片,视频,Andrei Alexandrescu谈到可能证明我们错了的共同直觉.对我来说,幻灯片7中出现了一个非常有趣的观点,他指出假设"更少的指令=更快的代码"是不正确的,更多的指令并不一定意味着更慢的代码.
这就是我的问题:他的谈话的音质(大约6:20分钟)不是那么好,我不太理解这个解释,但从我得到的是他将退役指令与算法的最优性进行比较绩效水平.
但是,根据我的理解,这是不可能做到的,因为这是两个独立的结构层面.说明(特别是实际上已退役的说明)是一项非常重要的措施,基本上可以让您了解实现目标的绩效.如果我们省略指令的延迟,我们可以推断出更少的退出指令=更快的代码.现在,当然有些情况下,在循环内执行复杂计算的算法即使在循环内执行也会产生更好的性能,因为它会更早地破坏循环(想想图遍历).但是,与复杂程度的算法进行比较而不是说这个循环有更多指令并且比另一个更好会不会更有用？从我的观点来看,更好的算法最终会有更少的退役指令.
有人可以帮助我了解他的例子,以及如何(显着)更多退休指令可以带来更好的表现吗？
我有2个int数组.
int[] data1 #
int[] data2 #
我想创建第3个int [] data3,这是其他2个数组之间的差异.
让我们取data1中的第一个值.
值为15(例如).
现在让我们在data2中取第一个值.
值为3(例如).
data3中的第一个值为12.
但是,如果第一个值是相反的,即
data1[0] = 3
data2[0] = 15
然后差异将是-12.但我希望它只有12岁.
目前我有一个for循环,我在那里做计算的东西来获得那种类型的结果.
谢谢
NB回应'关闭者'.我同意你的观点.我需要在这个问题上添加的是:
我正在寻找最有效(最快的方式,但低内存是第二优先)来促进这一点.使用Linq(据我所知)可能是最慢的方法？
我已阅读无处不在,对于分而治之的排序算法像Merge-Sort和Quicksort,而不是递归,直到只有一个元素是左,这是更好地转移到Insertion-Sort时候一定阈值,比如30元,达到.那很好,但为什么只有Insertion-Sort？为什么不,Bubble-Sort或Selection-Sort两者都有类似的O(N^2)表现？Insertion-Sort只有当许多元素被预先排序时才应该派上用场(虽然这个优势也应该附带Bubble-Sort),但除此之外,为什么它应该比其他两个元素更有效？
其次,在这个链接中,在第二个答案及其附带的评论中,它表示O(N log N)与O(N^2)最高级别相比表现不佳N.怎么会？N^2应该总是表现得比N log N,因为N > log N对于所有N> = 2,对吧？
我有一个int名为的矩阵A,当我通过列而不是行迭代它时,它运行速度大约50毫秒:
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
cout<<A[j][i]; //slower than of A[i][j]
有谁知道为什么会这样？我问了几个人,但他们都不知道为什么.我确定这与地址在计算机内存中的表示方式有关,但我仍然希望找到更具体的答案.
对于矩阵运算......
public static int[][] ijkAlgorithm(int[][] A, int[][] B) {
int n = A.length;
int[][] C = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}
return C;
}
public static int[][] ikjAlgorithm(int[][] A, int[][] B) {
int n = A.length;
int[][] C = new int[n][n];
for (int …有人问我一个问题:在以下两种情况中,哪一项是最快的:
for (int i = 0; i < 10; i++)
{
for (int j = 0; j < 5; j++)
{
count++;
}
}
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 10; j++)
{
count++;
}
}
在这两个场景中,计数的最终值将为50.但我不确定哪一个会更快？我认为CASE II更快但不确定......
如果有人能对它有所了解,那就太好了.哪个更快,为什么？
假设我有两个数组arrayOne并且arrayTwo在哪里arrayOne.length != arrayTwo.length(假设两个List具有不同的类似情况size()).以下任何一种都提供了速度优势吗？
选项1
for(int i = 0 ; i < arrayOne.length ; ++i) {
for(int j = 0 ; j < arrayTwo.length ; ++j) {
//Do something
}
}
选项2
for(int i = 0 ; i < arrayTwo.length ; ++i) {
for(int j = 0 ; j < arrayOne.length ; ++j) {
//Do something
}
}
哪个版本效率更高,为什么？似乎两者都进行相同的计算.我唯一能想到的是编译器是否认识到(a)j中没有改变值而不必一遍又一遍地计算它.任何输入都会很棒!
#define M /* some mildly large number */
double a[M*M], x[M], c[M];
int i, j;
(a) First version
for (j = 0; j < M; j++)
for (i = 0; i < M; i++)
c[j] += a[i+j*M]*x[i];
(b) Second version
for (i = 0; i < M; i++)
for (j = 0; j < M; j++)
c[j] += a[i+j*M]*x[i];