3 While Schleife zu einer

1

while(left <= leftEnd && right <= rightEnd)

2

{

3

            if(a[left].compareTo(a[right]) <= 0)

4

                tmp[k++] = a[left++];

5

            else{

6

                tmp[k++] = a[right++]; 

7

            }

8

            tmp[k++] = a[left++];

9

            tmp[k++] = a[right++];

10

}

???

Tipp 1:
Gewöhn Dir bitte an, die eigentliche Aufgabenstellung zu benennen. In 
diesem Fall also, was der Code den Du geschrieben hast überhaupt 
bewerkstelligen soll.

Tipp 2:
Gewöhn Dir bitte an, geschweifte Klammern zu verwenden wenn Du in C 
programmierst.


So wie der Code dasteht, werden die drei Schleifen nacheinander 
abgearbeitet. Ich nehme an das ist nicht das, was tatsächlich gemacht 
werden soll?

Das soll wohl ein Merge-Sort werden.

Wenn man das unbedingt in eine enzelne Schleife packen muss:

1

for(;;) {

2

  if(left <= leftEnd) {

3

    if(right <= rightEnd) {

4

      if(a[left].compareTo(a[right]) <= 0)

5

        tmp[k++] = a[left++];

6

      else

7

        tmp[k++] = a[right++];

8

    }

9

    else

10

      tmp[k++] = a[left++];

11

  }

12

  else {

13

    if(right <= rightEnd)

14

      tmp[k++] = a[right++];

15

    else

16

      break;

17

  }

18

}

Aber deine bisherige Lösung gefällt mir deutlich besser.

CCoder schrieb:
> Dann noch ein Versuch für den Herrn:while(left <= leftEnd && right <=
> rightEnd) {
>      if(a[left].compareTo(a[right]) <= 0)
>           tmp[k++] = a[left++];
>      else
>           tmp[k++] = a[right++];
> }
>
> while(left <= leftEnd) {
>      tmp[k++] = a[left++];
> }
>
> while(right <= rightEnd) {
>      tmp[k++] = a[right++];
> }

Die obere while-Schleife bricht ab, wenn einer der beiden Variablen left 
bzw. right ans Ende gelaufen sind, die beiden unteren while-Schleifen 
machen nichts anderes, als den verbleibenden Rest noch zu kopieren.

Ziehe beide unteren while-Bedingungen in die obere Schleife als 
if-Statement rein. Dann musst Du aber noch die Bedingung der ersten 
while Schleife ändern: && durch ||, damit die Schleife für beide 
Variablen bis zum Ende durchläuft. Der ursprüngliche Inhalt der ersten 
while-Schleife muss dann aber bedingt (if) durchgeführt werden.

Aber ob das insgesamt dadurch einfacher wird? Ich finde Deine Variante 
lesbarer.

Der Andere schrieb:
> Das fand ich jetzt auch nicht so toll. Das heisst für den nächsten warum
> selber machen, irgendeiner hier löst mir meine Aufgabe.

Ich habe ihm einen Anstoß gegeben, wie er das lösen kann - in Worten. 
Mehr nicht.

Yalu X. schrieb:

> Aber deine bisherige Lösung gefällt mir deutlich besser.

Wenn man das ganze in der Reihenfolge anders aufzieht, wird es deutlich 
lesbarer. Ich bezeichne die Arrays einfach einmal als Stapel. So ähnlich 
wie 2 Stapel Spielkarten, die (vorsortiert) zu einem gemeinsamen Stapel 
vereint werden sollen

1

 solange nicht beide Stapel leer sind

2

 {

3

   if( linker Stapel ist bereits leer )

4

     nimm vom rechten Stapel

5

6

   else if( rechter Stapel ist bereits leer )

7

     nimm vom linken Stapel

8

9

   else // offenbar sind beide Stapel noch nicht leer

10

     nimm von links oder rechts, basierend auf einem Wertevergleich

11

 }

Sieht man das ganze so an, dann reduzieren sich die Schachtelungen 
deutlich.

Du kannst natürlich sowas machen wie

1

while (left <= leftEnd || right <= rightEnd)

2

{

3

    if (right > rightEnd)

4

        tmp[k++] = a[left++];

5

    else if (left > leftEnd)

6

        tmp[k++] = a[right++];

7

    else if (a[left].compareTo(a[right]) <= 0)

8

        tmp[k++] = a[left++];

9

    else

10

        tmp[k++] = a[right++];

11

}

Aber dein ursprünglicher Code ist einfach besser verständlich.  Und 
alles in eine Schleife zu quetschen bringt keinerlei Vorteile (außer 
evtl. von nem Bremser mit zweifelhaften Kriterien Punkte einzusammeln).

CCoder schrieb:

> Jain. Das einzige was der Lehrer dazu meinte: Pack die Bedingungen der
> zweiten und der dritten Schleife in die erste, Verknüpf sie und schau
> dass dein Code mit nur einer Schleife auskommt. (Wieso auch immer...)

Damit es nicht mehr so einfach zu lesen ist und der optimizer ggf. 
wieder drei Schleifen draus macht.

Karl H. schrieb:
> Wenn man das ganze in der Reihenfolge anders aufzieht, wird es deutlich
> lesbarer. Ich bezeichne die Arrays einfach einmal als Stapel. So ähnlich
> wie 2 Stapel Spielkarten, die (vorsortiert) zu einem gemeinsamen Stapel
> vereint werden sollen
>

1

>  solange nicht beide Stapel leer sind

2

>  {

3

>    if( linker Stapel ist bereits leer )

4

>      nimm vom rechten Stapel

5

> 

6

>    else if( rechter Stapel ist bereits leer )

7

>      nimm vom linken Stapel

8

> 

9

>    else // offenbar sind beide Stapel noch nicht leer

10

>      nimm von links oder rechts, basierend auf einem Wertevergleich

11

>  }

>
> Sieht man das ganze so an, dann reduzieren sich die Schachtelungen
> deutlich.

Also für mich liest sich das Original so:

1

solange ( beide Stapel nicht leer sind )

2

    nimm von links oder rechts, basierend auf einem Wertevergleich

3

4

solange ( rechten Stapel nicht leer )

5

    nimm vom rechten Stapel

6

7

solange ( linker Stapel nicht leer )

8

    nimm vom linken Stapel

Das halte ich für eine Schachtelungsebene weniger als der geänderte 
Vorschlag. Obendrein werden unnötige Abfragen innerhalb der Schleife 
vermieden. Die einzige Hürde besteht vielleicht darin zu erkennen, dass 
immer mindestens eine der drei Schleifen nicht durchlaufen werden kann, 
aber die sollte mit ein wenig Übung locker zu nehmen sein.

CCoder schrieb:
> Jain. Das einzige was der Lehrer dazu meinte: Pack die Bedingungen der
> zweiten und der dritten Schleife in die erste, Verknüpf sie und schau
> dass dein Code mit nur einer Schleife auskommt. (Wieso auch immer...)

Ich würde meinen Lehrer ja mal fragen, warum er auf nur einer Schleife 
besteht. Ich sehe darin keinen Vorteil aber mindestens zwei Nachteile.

A. H. schrieb:

> Das halte ich für eine Schachtelungsebene weniger als der geänderte
> Vorschlag. Obendrein werden unnötige Abfragen innerhalb der Schleife
> vermieden. Die einzige Hürde besteht vielleicht darin zu erkennen, dass
> immer mindestens eine der drei Schleifen nicht durchlaufen werden kann,
> aber die sollte mit ein wenig Übung locker zu nehmen sein.

Ich bin bei dir. Aber wenn es sein Lehrer so haben will, dann will er so 
haben. Der Kunde ist König :-)

Karl H. schrieb:
> Ich bin bei dir. Aber wenn es sein Lehrer so haben will, dann will er so
> haben. Der Kunde ist König :-)

Und gerade Lehrer sind nicht unbedingt bekannt dafür, sich gerne von 
ihren Schülern belehren zu lassen. Mit anderen Worten: Meist verliert 
man eher, wenn man an der Stelle eine Diskussion anfängt.