• Startseite
  • Artikel
  • Allgemein
  • In Java Wie verschiebt man alle Nullen an das Ende des Arrays, um die Reihenfolge eines Arrays beizubehalten? [2 Wege]

In Java Wie verschiebt man alle Nullen an das Ende des Arrays, um die Reihenfolge eines Arrays beizubehalten? [2 Wege]

Veröffentlicht: 2020-12-31
In Java Wie verschiebt man alle Nullen an das Ende des Arrays, um die Reihenfolge eines Arrays beizubehalten? [2 Wege]

Ich habe mit dem Problem gespielt, in verschiedenen Interviews in verschiedenen Kombinationen moving all 0's to end von Arrays zu verschieben. Manchmal bitte ich darum, alle 0 an den Anfang des Arrays zu verschieben, ein Array ohne Datenstruktur zu sortieren und so weiter.

In diesem Tutorial werden wir ein einfaches Beispiel für das Verschieben aller Nullen durchgehen, um die Reihenfolge eines Arrays zu erhalten. Es gibt zwei Ansätze.

Ansatz-1)

QuickSort Partitionierungslogik. Was ist Pivot Point?

  • Pivot point ist ein Schlüsselelement im Quick Sort-Algorithmus. Es führt und partitioniert die Sammlung um den Drehpunkt herum.
  • Es ordnet ein Array Elemente an, die größer als der Pivot sind, und Elemente, die größer als der Pivot sind, danach.
  • Fahren Sie mit der Schleife fort, um ein Array zu sortieren

Logik ist ganz einfach:

  • Durchlaufen Sie ein Array.
  • Wenn array[i] nicht gleich 0 ist, dann tausche es mit dem aktuellen Index aus.
  • Wenn array[i] == 0, Schleife einfach überspringen
  • In unserem Fall 0 is a Pivot point .
  • Jedes Mal, wenn wir 0 gefunden haben, wird der Zähler-Pivot inkrementiert und das Element wird vor den Pivot-Punkt verschoben.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private static void approach1 ( int [ ] crunchifyData ) {
 
// Move 0 to end of array
int j = 0 ;
for ( int i = 0 ; i < crunchifyData . length ; i ++ ) {
if ( crunchifyData [ i ] ! = 0 ) {
int temp = crunchifyData [ j ] ;
crunchifyData [ j ] = crunchifyData [ i ] ;
crunchifyData [ i ] = temp ;
j ++ ;
}
}
 
log ( "\n\nApproach-1 Result: " + Arrays . toString ( crunchifyData ) ) ;
 
}

Ansatz-2)

  • Erstellen Sie ein neues Array mit derselben Größe
  • Durchlaufen Sie ein Array und überspringen Sie das Hinzufügen von 0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private static void approach2 ( int [ ] crunchifyData ) {
 
int [ ] num = new int [ crunchifyData . length ] ;
 
int j = 0 ;
for ( int i = 0 ; i < crunchifyData . length ; i ++ ) {
if ( crunchifyData [ i ] ! = 0 ) {
num [ i - j ] = crunchifyData [ i ] ;
} else {
j ++ ;
}
}
 
System . out . print ( "\n\nApproach-2 Result: " + Arrays . toString ( num ) ) ;
 
}

Hier ist ein vollständiges Programm:

CrunchifyMoveAll0ToEnd.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
package crunchify . com . java . tutorials ;
 
import java . util . Arrays ;
 
/**
* @author Crunchify.com
* Requirement: Move all 0's to end of array preserving order
* Input array: 8 8 3 0 4 0 6 0 9 1
* Output array: 8 8 3 4 6 9 1 0 0 0
*/
 
public class CrunchifyMoveAll0ToEnd {
 
     public static void main ( String [ ] args ) {
 
         int [ ] crunchifyData ;
         crunchifyData = new int [ ] { 8 , 8 , 3 , 0 , 4 , 0 , 6 , 0 , 9 , 1 } ;
 
         log ( "Original array: " + Arrays . toString ( crunchifyData ) ) ;
 
         if ( crunchifyData == null | | crunchifyData . length == 0 ) {
             log ( "Empty Array" ) ;
         }
 
         approach1 ( crunchifyData ) ;
         approach2 ( crunchifyData ) ;
     }
 
     private static void approach1 ( int [ ] crunchifyData ) {
 
         // Move 0 to end of array
         int j = 0 ;
         for ( int i = 0 ; i < crunchifyData . length ; i ++ ) {
             if ( crunchifyData [ i ] ! = 0 ) {
                 int temp = crunchifyData [ j ] ;
                 crunchifyData [ j ] = crunchifyData [ i ] ;
                 crunchifyData [ i ] = temp ;
                 j ++ ;
             }
         }
 
         log ( "\n\nApproach-1 Result: " + Arrays . toString ( crunchifyData ) ) ;
 
     }
 
     // Create a new array with same size
     // Iterate through an Array and skip adding 0
     private static void approach2 ( int [ ] crunchifyData ) {
 
         int [ ] num = new int [ crunchifyData . length ] ;
 
         int j = 0 ;
         for ( int i = 0 ; i < crunchifyData . length ; i ++ ) {
             if ( crunchifyData [ i ] ! = 0 ) {
                 num [ i - j ] = crunchifyData [ i ] ;
             } else {
                 j ++ ;
             }
         }
 
         System . out . print ( "\n\nApproach-2 Result: " + Arrays . toString ( num ) ) ;
 
     }
 
     private static void log ( String string ) {
 
         System . out . print ( string + " " ) ;
     }
 
}

Ausgabe der Eclipse-Konsole:

1
2
3
4
5
6
Original array : [ 8 , 8 , 3 , 0 , 4 , 0 , 6 , 0 , 9 , 1 ]
 
Approach - 1 Result : [ 8 , 8 , 3 , 4 , 6 , 9 , 1 , 0 , 0 , 0 ]
 
Approach - 2 Result : [ 8 , 8 , 3 , 4 , 6 , 9 , 1 , 0 , 0 , 0 ]
Process finished with exit code 0

Lassen Sie mich wissen, wenn Sie einen besseren Weg kennen, um dieses Problem zu lösen. Ich würde gerne Ihre Meinung hören.