Optimiert Bubble-Sort (Java)

Zuerst von allen, haben Sie eine out-of-bounds Zugriff:

    for(int j=0; j<a.length; j++) {
      if(a[j] > a[j+1]) {

für j == a.length-1, so dass die Schleife Bedingung sollte eher sein j < a.length-1.

Aber in der Bubble-sort, wissen Sie, dass nach k geht, die größte k Elemente sind sortiert in die k letzten Einträge des Arrays, also die herkömmlichen Bubble-sort verwendet

public static void bubblesort(int[] a) {
  for(int i=1; i<a.length; i++) {
    boolean is_sorted = true;

    for(int j=0; j < a.length - i; j++) { //skip the already sorted largest elements
      if(a[j] > a[j+1]) {
         int temp = a[j];
         a[j] = a[j+1];
         a[j+1] = temp;
         is_sorted = false;
      }
    }

    if(is_sorted) return;
  }
}

Nun, das würde noch eine Menge von unnötigen Iterationen, wenn das array hat eine lange sortiert tail der größten Elemente, sagen, Sie haben k,k-1,...,1 als die ersten k Elemente und k+1 zu 100000000 um danach. Der standard-Bubble-sort passieren k mal durch (fast) das gesamte array.

Aber wenn Sie sich erinnern, wo Sie Ihre letzten swap, wissen Sie, dass nach diesem index sind die größten Elemente in der Reihenfolge, so

public static void bubblesort(int[] a) {
  int lastSwap = a.length-1;
  for(int i=1; i<a.length; i++) {
    boolean is_sorted = true;
    int currentSwap = -1;

    for(int j=0; j < lastSwap; j++) {
      if(a[j] > a[j+1]) {
         int temp = a[j];
         a[j] = a[j+1];
         a[j+1] = temp;
         is_sorted = false;
         currentSwap = j;
      }
    }

    if(is_sorted) return;
    lastSwap = currentSwap;
  }
}

Sortieren würde das obige Beispiel mit nur einem Durchlauf durch das gesamte array, und die restlichen Pässe nur durch ein (kurzer) Präfix.

Natürlich im Allgemeinen, dass nicht kaufen Sie viel, aber dann die Optimierung ein Bubble-sort ist ein eher aussichtsloses Unterfangen sowieso.

sollten Sie eine variable "Größe" für die innere Schleife und ändern Sie es auf den neuesten getauscht element in jedem Zyklus.Auf diese Weise Ihre innere Schleife geht bis zu der neuesten "ausgelagert" - element und übergibt den rest, die unswapped (aka in Ihren correctplace). ich.e

do {
        int newsize =0;
        for (int i = 1; i < size; i++) {
            if (a[i - 1] > a[i]) {
                int temp;
                temp = a[i - 1];
                a[i - 1] = a[i];
                a[i] = temp;
                newsize =i;
            }
        }
        size = newsize;
   } while (size > 0);

Ich eine Methode entwickelt, reduziert die Anzahl der Iterationen, die durch den Ausschluss von teilen am Anfang und Ende des Arrays, die bestellt wurden, die in vorherigen Schleifen.

static int[] BubbleSortOptimized(int arr[]) {
    int start = 0, stop = arr.length - 1, control = 0;
    boolean ordered, nsCaught;
    while (true){
        ordered = true;
        nsCaught = false;
        for (int i = start; i < stop; i++) {
            if (i > 1) {
                if (!nsCaught && arr[i-2] > arr[i-1]){
                    ordered = false;
                    start = i-2;
                    nsCaught = true;
                }
            }
            if (arr[i] > arr[i+1]){
                int hold = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = hold;
                control = i;
            }
        }
        System.out.println(Arrays.toString(arr));
        if (ordered) return arr;
        stop = control;
    }
}

Aber als @Daniel Fischer sagte in einer früheren Antwort, es macht nicht viel mit größeren arrays.

public class Tester {
    static boolean bubbleFlag = true;

    public static void main(String[] args) {
        int array[] = new int[] {
            1,
            9,
            2,
            3,
            4,
            5,
            6
        };
        bubbleSort(array);
    }

    private static void bubbleSort(int...array) {
        System.out.println("Before Sorting: " + Arrays.toString(array));

        for (int i = 0; i < array.length - 1; i++) {
            if (i > 0) if (bubbleFlag) break;

            for (int j = 0; j < array.length - i - 1; j++) {
                if (array[j] > array[j + 1]) array = swap(j, j + 1, array);
                System.out.println("Iteration " + i + " :" + Arrays.toString(array));
            }
            bubbleFlag = true;
        }
    }

    private static int[] swap(int i1, int i2, int...is) {
        bubbleFlag = false;
        is[i1] = is[i1] + is[i2];
        is[i2] = is[i1] - is[i2];
        is[i1] = is[i1] - is[i2];
        return is;
    }
}

Optimiert bubble-sort mit nur 1 Schleife

/*Advanced BUBBLE SORT with ONE PASS*/
/*Authored by :: Brooks Tare  AAU*/

public class Bubble {

    public int[] bubble(int b[]){ 
    int temp,temp1; 

    for(int i=0;i<b.length-1;i++){

            if(b[i]>b[i+1] ){
                ///swap(b[i],b[i+1]);

                temp=b[i];
                b[i]=b[i+1];
                b[i+1]=temp;

    /*Checking if there is any number(s) greater than 
      the current number. If there is swap them.*/
                while(i>0){


                    if(b[i]<b[i-1]){
                    ///swap(b[i]<b[i-1])

                        temp1=b[i];
                        b[i]=b[i-1];
                        b[i-1]=temp1;
                        i--;
                    }
                    else if(b[i]>b[i-1]){i--;}
                }
            }
            else{continue;}

        }



        return b;
    }
///the following is a function to display the Array 
        public void see(int []a){
            for(int j=0;j<a.length;j++){
                System.out.print(a[j]+",");
            }
        }



    public static void main(String []args){
        ///You can change the Array to your preference.. u can even make it dynamic 

        int b[]={5,1,4,2,0,3}; 
        int v[]=new int[100]; 
        Bubble br=new Bubble();
        v=br.bubble(b);
        br.see(v);

    }
}