Ich habe hier eine 2D Array A[n][m] und möchte alle Einträge einmal Paarweise vergleichen, also für n=2, m=2, wäre das dann
(0,0) mit (0,1), (1,0), (1,1)
(0,1) mit (1,0), (1,1)
(1,0) mit (1,1)

Ich weis nur grad nicht weiter:

for(int i=0; i<n; i++) {
	for(int j=0; j<m; j++) {
		for(int i2=0; i2<n; i2++) {
			for(int j2=0; j2<m; j2++) {
				//Vergleiche (i,j) mit (i2,j2)
			}
		}
	}
}

Wie verhindere ich jetzt die ganzen doppelten Vergleiche .
Für 1D wäre es einfach:

for(int i=0; i<n-1; i++) {
	for(int j=i+1; j<n; j++) {		
		//Vergleiche i und j			
	}
}

Danke!

Eine andere Idee: Behandle den 2-Dimensionalen Array einfach so als wäre es ein eindimensionaler. Die Werte liegen ja sowieso hintereinander im Speicher.
Schau dir vielleicht mal folgenden Code an:

#include <iostream>

int main()
{
  int data[2][2];
  data[0][0] = 1;
  data[0][1] = 2;
  data[1][0] = 3;
  data[1][1] = 4;

  for(int i=0; i<4; ++i)
    {
      std::cout << "data[" << i/2 << "]" << "[" << i%2 << "] = " << *(*data+i)  << std::endl;
    }
}

Die Ausgabe ist

data[0][0] = 1
data[0][1] = 2
data[1][0] = 3
data[1][1] = 4

Dann kannst du deine 1D-Variante verwenden.

Max3000 schrieb:

Ich würde mal vermuten, dass du i2 einfach nur ab i+1 und j2 ab j+1 laufen lassen musst.

Das geht nicht, hab ich auch erst gedacht, man sieht aber schnell, dass Vergleiche übersprungen werden.

Hmm, da ich einen Vector im Vector von Klassen habe, kann ich das nicht so einfach mit '*' dereferenzieren, zumindest weis ich nicht wie.

#include <iostream>

int main()
{
  const int n = 2;
  const int m = 3;
  int data[n][m];
  data[0][0] = 1;
  data[0][1] = 2;
  data[0][2] = 3;
  data[1][0] = 4;
  data[1][1] = 5;
  data[1][2] = 6;

  for(int i=0; i<n; i++)
  {
    for(int j=0; j<m; j++)
    {
      for(int i2=i; i2<n; i2++)
      {
        for(int j2 = i == i2 ? j+1 : 0; j2<m; j2++)
        {
          std::cout << "Vergleicht data[" << i << "][" << j << "] mit data[" << i2 << "][" << j2 << "]\n";
        }
      }
      std::cout << '\n';
    }
  }
}

Ausgabe:

Vergleicht data[0][0] mit data[0][1]
Vergleicht data[0][0] mit data[0][2]
Vergleicht data[0][0] mit data[1][0]
Vergleicht data[0][0] mit data[1][1]
Vergleicht data[0][0] mit data[1][2]

Vergleicht data[0][1] mit data[0][2]
Vergleicht data[0][1] mit data[1][0]
Vergleicht data[0][1] mit data[1][1]
Vergleicht data[0][1] mit data[1][2]

Vergleicht data[0][2] mit data[1][0]
Vergleicht data[0][2] mit data[1][1]
Vergleicht data[0][2] mit data[1][2]

Vergleicht data[1][0] mit data[1][1]
Vergleicht data[1][0] mit data[1][2]

Vergleicht data[1][1] mit data[1][2]

Hi, hab ich nicht gerafft...
Ich komm nicht auf die sinnvolle Sortierung um durchzuzählen.

ein nxm array kannst du auch als 1-D array der länge m*n auffassen.Und dann bist du wieder ind einem bequemen 1-D Fall.

#include <iostream>

int main()
{
  const int n = 2;
  const int m = 3;

  for (int i = 0; i < n*m-1; ++i)
  {
    for (int j = i+1; j < n*m; ++j)
    {
      std::cout << "Vergleicht data[" << i/m << "][" << i%m
                << "] mit data[" << j/m << "][" << j%m << "]\n";
    }
    std::cout << '\n';
  }

}