排序(Sort)

10^11

目錄

  • 泡沫排序 Bubble Sort
  • 合併排序 Merge Sort

排序演算法(Sorting algorithm)

先來talk talk 什麼是排序演算法

排序演算法(Sorting algorithm)

一種能將一串資料依照特定排序方式排列的演算法

其中，有六個較為常見的排序方式：

 

1.泡沫排序(Bubble Sort)

2.插入排序(Insertion Sort)

3.選擇排序(Selection Sort)

4.快速排序(Quick Sort)

5.合併排序(Merge Sort)

6.堆排序(Heap Sort)

排序演算法(Sorting algorithm)

穩定排序法(stable sorting)：

如果鍵值相同之資料，在排序後相對位置與排序前相同時，稱穩定排序

eg:

3,1,3*,6   ->   1,3,3*,6

 

不穩定排序法(unstable sorting)：

如果鍵值相同之資料，在排序後相對位置與排序前不相同時，稱不穩定排序。

eg:

3,1,3*,6   ->   1,3*,3,6

排序演算法(Sorting algorithm)

穩定排序法(stable sorting)：

 

排序演算法(Sorting algorithm)

不穩定排序法(unstable sorting)：

 

選擇排序（selection sort）

希爾排序（shell sort）

梳排序

堆積排序（heap sort）

平滑排序（smooth sort）

快速排序（quick sort）

內省排序（introsort）

耐心排序（patience sort）

泡沫排序(Bubble Sort)

它重複地走訪要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。

這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端。

它重複地走訪要排序的數列，一次比較兩個元素，如果它們的順序錯誤就把它們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。

這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端。

為穩定排序法。

泡沫排序(Bubble Sort)

這個演算法是最簡單瞭解和實作的排序演算法之一，

但它對於包含大量的元素的數列排序是很沒有效率的。

它和這隻生物不同，

它需要花很多時間才能完成

泡沫排序(Bubble Sort)

步驟說明：

 

  1. 1.比較相鄰的元素。如果第一個比第二個大，就交換它們兩個。
  2.  
  3. 2.對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。
  4.    這步做完後，最後的元素會是最大的數。
  5.  
  6. 3.針對所有的元素重複以上的步驟，除了最後一個。
  7.  
  8. 4.持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

泡沫排序(Bubble Sort)

遞迴法程式碼(可輸入輸出版本)

#include <bits/stdc++.h>
using namespace std;

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n-1; i++) {
        for (int j = 0; j < n-i-1; j++) {
            if (arr[j] > arr[j+1]) {
                // 交換arr[j]和arr[j+1]
                int x = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = x;
            }
        }
    }
}

int main() {
    int arr[] = {6,5,4,3,2,1};
    int n = 6;
    cout << "原始數列：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    bubbleSort(arr, n);
    
    cout << "排序後數列：";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
    
    return 0;
}

合併排序(Merge Sort)

MergeSort 是一種經典的分治排序演算法，其主要思想是將待排序的陣列分割成兩個子陣列，然後分別對這兩個子陣列進行排序，最後再將排好序的子陣列合併起來。

為穩定排序法。

  1. 分割（Divide）

  2. 排序（Sort）

  3. 合併（Merge）

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

分割程式碼

void MergeSort(int Array[], int front, int end) {
    if (front < end) {
        //重複直到每個分組只剩下一個值
        int mid = front + (end - front) / 2; // 計算中間值
        MergeSort(Array, front, mid);
        MergeSort(Array, mid + 1, end);//遞迴對左右兩部分進行排序
        Merge(Array, front, mid, end);//合併到原始陣列中
    }
}

合併排序(Merge Sort)

讀取陣列程式碼

void Merge(int Array[], int front, int mid, int end) {
    // 將陣列分成兩個子陣列，並複製到 LeftSubArray 和 RightSubArray
    int n1 = mid - front + 1; // 計算左子陣列的大小
    int n2 = end - mid; // 計算右子陣列的大小
    int LeftSubArray[n1], RightSubArray[n2];
    // 將元素複製到左子陣列
    for (int i = 0; i < n1; i++)
        LeftSubArray[i] = Array[front + i];
    // 將元素複製到右子陣列
    for (int j = 0; j < n2; j++)
        RightSubArray[j] = Array[mid + 1 + j];
    }

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

合併排序(Merge Sort)

排序+合併程式碼

void Merge(int Array[], int front, int mid, int end) {
int i = 0, j = 0, k = front;
    // 將左右子陣列中的元素進行比較，合併到原始陣列中
    while (i < n1 && j < n2) {
        if (LeftSubArray[i] <= RightSubArray[j]) {
            Array[k] = LeftSubArray[i];
            i++;
        } 
        else {
            Array[k] = RightSubArray[j];
            j++;
        }
        k++;
    }
    }

合併排序(Merge Sort)

最終判斷程式碼

void Merge(int Array[], int front, int mid, int end) {
 
// 將左子陣列中剩餘的元素放入原始陣列
    while (i < n1) {
        Array[k] = LeftSubArray[i];
        i++;
        k++;
    }
    // 將右子陣列中剩餘的元素放入原始陣列
    while (j < n2) {
        Array[k] = RightSubArray[j];
        j++;
        k++;
    }
   }

合併排序(Merge Sort)

合併排序(Merge Sort)

遞迴法程式碼(理解用版本)

#include <bits/stdc++.h>
using namespace std;

void Merge(int Array[], int front, int mid, int end) {
    // 將陣列分成兩個子陣列，並複製到 LeftSubArray 和 RightSubArray
    int n1 = mid - front + 1; // 計算左子陣列的大小
    int n2 = end - mid; // 計算右子陣列的大小
    int LeftSubArray[n1], RightSubArray[n2];
    // 將元素複製到左子陣列
    for (int i = 0; i < n1; i++)
        LeftSubArray[i] = Array[front + i];
    // 將元素複製到右子陣列
    for (int j = 0; j < n2; j++)
        RightSubArray[j] = Array[mid + 1 + j];

    int i = 0, j = 0, k = front;
    // 將左右子陣列中的元素進行比較，合併到原始陣列中
    while (i < n1 && j < n2) {
        if (LeftSubArray[i] <= RightSubArray[j]) {
            Array[k] = LeftSubArray[i];
            i++;
        } else {
            Array[k] = RightSubArray[j];
            j++;
        }
        k++;
    }
    // 將左子陣列中剩餘的元素放入原始陣列
    while (i < n1) {
        Array[k] = LeftSubArray[i];
        i++;
        k++;
    }
    // 將右子陣列中剩餘的元素放入原始陣列
    while (j < n2) {
        Array[k] = RightSubArray[j];
        j++;
        k++;
    }
}

void MergeSort(int Array[], int front, int end) {
    if (front < end) {
        // 計算中間索引，並遞迴地對左右兩部分進行排序和合併
        int mid = front + (end - front) / 2;
        MergeSort(Array, front, mid);
        MergeSort(Array, mid + 1, end);
        Merge(Array, front, mid, end);
    }
}

合併排序(Merge Sort)

遞迴法程式碼(可輸入輸出版本)

#include <iostream>
using namespace std;

// 合併兩個已排序的子陣列
void Merge(int Array[], int front, int mid, int end) {
    // 計算左右子陣列的大小
    int n1 = mid - front + 1;
    int n2 = end - mid;

    // 創建左右子陣列
    int LeftSubArray[n1], RightSubArray[n2];

    // 複製元素到左子陣列
    for (int i = 0; i < n1; i++)
        LeftSubArray[i] = Array[front + i];
    
    // 複製元素到右子陣列
    for (int j = 0; j < n2; j++)
        RightSubArray[j] = Array[mid + 1 + j];

    int i = 0, j = 0, k = front;
    // 合併左右子陣列到原始陣列中
    while (i < n1 && j < n2) {
        if (LeftSubArray[i] <= RightSubArray[j]) {
            Array[k] = LeftSubArray[i];
            i++;
        } 
        else {
            Array[k] = RightSubArray[j];
            j++;
        }
        k++;
    }

    // 將左子陣列中剩餘的元素放入原始陣列
    while (i < n1) {
        Array[k] = LeftSubArray[i];
        i++;
        k++;
    }

    // 將右子陣列中剩餘的元素放入原始陣列
    while (j < n2) {
        Array[k] = RightSubArray[j];
        j++;
        k++;
    }
}

// 遞迴排序
void MergeSort(int Array[], int front, int end) {
    if (front < end) {
        // 計算中間索引，並遞迴地對左右兩部分進行排序和合併
        int mid = front + (end - front) / 2;
        MergeSort(Array, front, mid);
        MergeSort(Array, mid + 1, end);
        Merge(Array, front, mid, end);
    }
}

int main() {
    int Array[6];
    cout << "Enter 6 elements: ";
    for (int i = 0; i < 6; ++i)
        cin >> Array[i];

    MergeSort(Array, 0, 5);

    cout << "Sorted array: ";
    for (int i = 0; i < 6; ++i)
        cout << Array[i] << " ";
    cout << endl;

    return 0;
}

#include <bits/stdc++.h>
using namespace std;

// 合併兩個已排序的子陣列
void Merge(int Array[], int front, int mid, int end) {
    // 計算左右子陣列的大小
    int n1 = mid - front + 1;
    int n2 = end - mid;

    // 創建左右子陣列
    int LeftSubArray[n1], RightSubArray[n2];

    // 複製元素到左子陣列
    for (int i = 0; i < n1; i++)
        LeftSubArray[i] = Array[front + i];
    
    // 複製元素到右子陣列
    for (int j = 0; j < n2; j++)
        RightSubArray[j] = Array[mid + 1 + j];

    int i = 0, j = 0, k = front;
    // 合併左右子陣列到原始陣列中
    while (i < n1 && j < n2) {
        if (LeftSubArray[i] <= RightSubArray[j]) {
            Array[k] = LeftSubArray[i];
            i++;
        } 
        else {
            Array[k] = RightSubArray[j];
            j++;
        }
        k++;
    }

    // 將左子陣列中剩餘的元素放入原始陣列
    while (i < n1) {
        Array[k] = LeftSubArray[i];
        i++;
        k++;
    }

    // 將右子陣列中剩餘的元素放入原始陣列
    while (j < n2) {
        Array[k] = RightSubArray[j];
        j++;
        k++;
    }
}

// 遞迴排序
void MergeSort(int Array[], int front, int end) {
    if (front < end) {
        // 計算中間索引，並遞迴地對左右兩部分進行排序和合併
        int mid = front + (end - front) / 2;
        MergeSort(Array, front, mid);
        MergeSort(Array, mid + 1, end);
        Merge(Array, front, mid, end);
    }
}

int main() {
    int Array[6];
    cout << "Enter 6 elements: ";
    for (int i = 0; i < 6; ++i)
        cin >> Array[i];

    MergeSort(Array, 0, 5);

    cout << "Sorted array: ";
    for (int i = 0; i < 6; ++i)
        cout << Array[i] << " ";
    cout << endl;

    return 0;
}

合併排序(Merge Sort)

可愛動畫的連結，保證幫助思考：

請點這裡

樹狀圖講解：

請點這裡

kahoot!

Made with Slides.com