在 Java 中的氣泡排序演算法對手動連結串列進行排序

1. Java 中的氣泡排序
2. Java 中的氣泡排序手動連結串列
3. Java 中的類排序連結串列

氣泡排序是用於對資料集合進行排序的最常見的資料結構演算法。它通過以錯誤的順序迭代和交換相鄰元素直到它們正確來起作用。

我們將首先向你展示基本的排序演示。然後我們將實現兩個氣泡排序演算法來對 Java 中的連結串列進行排序。

Java 中的氣泡排序

讓我們保持基本的東西，而不涉及排序的算術方面。我們將在氣泡排序中從頭到尾遍歷一個陣列。

然後只有它可以將當前索引與下一個索引進行比較。該公式的核心概念是噹噹前元素的大小大於下一個元素時。

語法：

for (int A = 0; A < sort - 1; A++)
  for (int B = 0; B < sort - A - 1; B++)
    if (DEMO[B] > DEMO[B + 1]) {
      // Swapping of array
      int temp = DEMO[B];
      DEMO[B] = DEMO[B + 1];
      DEMO[B + 1] = temp;
    }

現在讓我們在 Java 中執行一個簡單的氣泡排序演算法。但首先，看看陣列未排序索引的初始狀態。

陣列：{43, 65, 21, 64, 12, 6, 1}

以下程式碼塊將通過應用此基本排序演算法對此陣列索引執行氣泡排序。

值得一提的是，我們總是可以根據自己的要求修改這個公式。但是，此時核心應該保持基本以形成清晰。

程式碼：

// In this program, we will sort an array DEMO using the bubble sort algorithm
// Main class
public class BubbleSortLinkListExample1 {
  // Main function
  private void bubbleSort(int DEMO[]) {
    // Using .length to determine entire length of array's index
    int sort = DEMO.length;
    // If array's length is less than int sort, increase it by 1
    for (int A = 0; A < sort - 1; A++)
      // Formula 1
      for (int B = 0; B < sort - A - 1; B++)
        if (DEMO[B] > DEMO[B + 1]) {
          // Swapping of array
          int temp = DEMO[B];
          DEMO[B] = DEMO[B + 1];
          DEMO[B + 1] = temp;
        }
  }
  /* Now we are going to print DEMO array*/
  void printArray(int DEMO[]) {
    int sort = DEMO.length;
    for (int A = 0; A < sort; ++A) System.out.print(DEMO[A] + " ");
    System.out.println();
  }
  // We are going to implement a driver algorithm for sorting our DEMO array
  public static void main(String args[]) {
    BubbleSortLinkListExample1 ob = new BubbleSortLinkListExample1();
    int DEMO[] = {43, 65, 21, 64, 12, 6, 1};
    ob.bubbleSort(DEMO);
    System.out.println("After the array has been sorted!");
    ob.printArray(DEMO);
  }
}

對這個陣列進行升序排序後，我們得到 Java 的輸出。

輸出：

After the array has been sorted!
1 6 12 21 43 64 65

Java 中的氣泡排序手動連結串列

連結串列手動排序也是氣泡排序中一種直接的方法。

我們之前討論過遍歷資料嗎？現在，我們將實踐它。

節點允許我們將資料從一個節點遍歷到下一個節點。

看看我們下面的演示模型。由於我們在前面的示例中確實執行了排序，因此在這裡強調節點非常重要。

Java 中的類排序連結串列

正如我們所理解的，我們應用這個類來形成 Java 中的節點。

程式碼：

class SortLL {
  public static class Mynode {
    int indx;
    Mynode fwdMynode;

    public Mynode(int indx) {
      this.indx = indx;
      this.fwdMynode = null;
    }
    public int getindx() {
      return this.indx;
    }
  }

你可以單獨使用這些類並呼叫它們的物件，但這是一種冗長而複雜的方式。因此，我們將所有類儲存在一個檔案中。

同樣，我們將使用 .getNextNode() 函式，它檢索下一個不帶引數的類元素。你必須熟悉這個概念，所以讓我們執行手動氣泡排序演算法，不用多說。

1. 排序之前的連結串列：

   

程式碼：

```java
class SortLL {
  public static class Mynode {
    int indx;
    Mynode fwdMynode;

    public Mynode(int indx) {
      this.indx = indx;
      this.fwdMynode = null;
    }
    public int getindx() {
      return this.indx;
    }
  }
  // My node class
  private Mynode head;
  private int size;
  public SortLL() {
    this.head = null;
    this.size = 0;
  }
  public void add(int indx) {
    Mynode Mynode = new Mynode(indx);
    if (head == null) {
      head = Mynode;
    } else {
      Mynode CN = head;
      while (CN.fwdMynode != null) {
        CN = CN.fwdMynode;
      }
      CN.fwdMynode = Mynode;
    }
    size++;
  }
  public void sort() {
    if (size > 1) {
      boolean dtr;
      do {
        Mynode thisMynode = head;
        Mynode ladtMynode = null;
        Mynode fwd = head.fwdMynode;
        dtr = false;

        while (fwd != null) {
          if (thisMynode.indx > fwd.indx) {
            dtr = true;
            if (ladtMynode != null) {
              Mynode sig = fwd.fwdMynode;

              ladtMynode.fwdMynode = fwd;
              fwd.fwdMynode = thisMynode;
              thisMynode.fwdMynode = sig;
            } else {
              Mynode sig = fwd.fwdMynode;
              head = fwd;
              fwd.fwdMynode = thisMynode;
              thisMynode.fwdMynode = sig;
            }
            ladtMynode = fwd;
            fwd = thisMynode.fwdMynode;
          } else {
            ladtMynode = thisMynode;
            thisMynode = fwd;
            fwd = fwd.fwdMynode;
          }
        }
      } while (dtr);
    }
  }
  public int listSize() {
    return size;
  }
  public void printindx() {
    Mynode CN = head;

    while (CN != null) {
      int indx = CN.getindx();
      System.out.print(indx + " ");
      CN = CN.fwdMynode;
    }
    System.out.println();
  }
  public boolean isEmpty() {
    return size == 0;
  }
}
// indxInterface class
class SrtBubb {
  public static void main(String[] args) {
    SortLL s = new SortLL();
    s.add(12);
    s.add(2);
    s.add(7);
    s.add(19);
    s.add(23);
    s.add(9);
    System.out.println("Before Performing Bubble Sort");
    s.printindx();
    s.sort();
    System.out.println("After Performing Bubble Sort");
    s.printindx();
    System.out.println("Size of the linked list is: " + s.listSize());
  }
}
```

2. 執行手動氣泡排序後：

   

   輸出：

   Before Performing Bubble Sort
   12 2 7 19 23 9
   After Performing Bubble Sort
   2 7 9 12 19 23
   Size of the linked list is: 6
   

你可以根據你的要求修改此程式。但這是初學者理解使用氣泡排序對連結串列進行手動排序的最實用的方法。

假設你仍然對這個話題感到困惑。我們還為你提供了檔案目錄中的程式碼。