Die Reihenfolge einer ArrayList umkehren und zwei ArrayLists zusammenführen

Question

Also versuche ich einige Methoden in meiner Array-Klasse von regulären Arrays in ArrayLists zu konvertieren. Ich habe jedoch zwei unterschiedliche Probleme festgestellt. Erstens, während ich die Reihenfolge meiner ArrayList umkehre, habe ich bemerkt, dass es merkwürdigerweise ausgibt, sage ich, wenn ich 6 ganze Zahlen habe, und ich versuche, umzukehren, wird es die Indexpositionen der ersten 3 und die tatsächlichen ganzen Zahlen ausgeben zuletzt 3. Zum Beispiel wird es ausgedruckt: umgekehrte Reihenfolge: 5, 4, 3, 96, 87, 24, In der Reihenfolge: falsch. Was ich ausdrucken möchte, ist 941, 874, 102, 96, 87, 24, In der Reihenfolge: falsch. In Bezug auf das Zusammenführen meiner zwei Array-Listen bin ich mir nicht sicher, ob es korrekt zusammengeführt wird, da ich nicht sicher bin, wie ich diese Codezeile konvertieren soll, um eine ArrayList auszudrucken. Ich habe diese beiden Codezeilen verwendet, um meine zusammengeführten Arrays ursprünglich auszudrucken.

int merged[] = merge(num3,num4); 
print(merged); 

Hier sind die Methoden, die ich der Arraylist und das Verfahren umgekehrt bin mit den beiden zu fusionieren:

/***  <<< CODE NOT COMPLETE >>> 
    * reverses the order of the elemets in the array 
    ***/ 
    public static void reverse(ArrayList <Integer> a) 
    { 
     for (int i = 0; i < a.size()/2; i++) 
     { 
      int reverseOrder = a.get(i); 
      a.set(i, a.size() - 1 - i); 
      a.set(a.size() - 1 - i, reverseOrder); 
     } 
    } 

    /***  <<< CODE NOT COMPLETE >>> 
    * merges two sorted arrays into 1 new array, maintains the sorted order 
    ***/ 
    public static ArrayList <Integer> merge (ArrayList <Integer> a, ArrayList <Integer> b) 
    { 
     ArrayList <Integer> merge = new ArrayList <Integer> (a.size() + b.size()); 
     int i = 0, j = 0, k = 0; 

     while (i < a.size() && j < b.size()) 
     { 
      if (a.get(i) < b.get(j)) 
      { 
       merge.set(k++, a.get(i++)); 
      } 

      else   
      { 
       merge.set(k++, b.get(j++)); 
      } 
     } 

     while (i < a.size()) 
     { 
      merge.set(k++, a.get(i++)); 
     } 

     while (j < b.size()) 
     { 
      merge.set(k++, b.get(i++)); 
     } 

     return merge; 
    } 

Answer 1

In public static void reverse(ArrayList <Integer> a) dieses

a.set(i, a.size() - 1 - i); // <-- the index, not the value. 
a.set(a.size() - 1 - i, reverseOrder); 

sollte

a.set(i, a.get(a.size() - 1 - i)); // <-- the value. 
a.set(a.size() - 1 - i, reverseOrder); 

Sie al Also haben Sie einen Tippfehler in Ihrem merge, wo Sie i++ in der letzten Schleife verwenden. Aber wirklich, sollten Sie die List Schnittstelle bevorzugen. Außerdem benötigen Sie nicht k, da die List einen internen Index enthält. Sie müssen auch nicht explizit Ihre List Größe (aber ich habe hier, um mit Ihrem Code konsistent sein). Und ich würde die size (s) speichern. Wie,

public static List<Integer> merge(List<Integer> a, List<Integer> b) { 
    final int aLen = a.size(), bLen = b.size(); 
    List<Integer> al = new ArrayList<>(aLen + bLen); 
    int i = 0, j = 0; 
    while (i < aLen && j < bLen) { 
     if (a.get(i) < b.get(j)) { 
      al.add(a.get(i++)); 
     } else { 
      al.add(b.get(j++)); 
     } 
    } 
    while (i < aLen) { 
     al.add(a.get(i++)); 
    } 
    while (j < b.size()) { 
     al.add(b.get(j++)); 
    } 
    return al; 
}