C++語言菜鳥快速入門

C++ 標準模板庫（STL）提供了一套豐富的即用型資料結構和演算法，簡化了程式碼開發並提高了效率。 C++ 支援各種程式設計範例，包括物件導向、過程和泛型程式設計，提供瞭解決問題方法的靈活性。

為何C++ 最適合競爭性程式設計
競爭性程式設計青睞 C++，因為它能夠兼具效率和多功能性。執行時透過其低階功能進行了最佳化，這些功能提供了對演算法的細粒度控制。標準模板庫 (STL) 簡化了程式碼開發，它提供了即用型資料結構和演算法。 C++ 支援物件導向、過程和泛型程式設計，允許採用多種方法來解決問題。

其快速執行和記憶體管理也有助於更快地解決問題，這在時間至關重要的比賽中非常重要。 C++ 是那些希望解決方案具有速度、效率和靈活性的競爭性程式設計師的首選語言，因為它平衡了表達能力、效能和豐富的內建功能。

分析了 C++ 在競爭性程式設計方面的最佳特性。

STL（標準模板庫）： C++ 附帶了一個名為 STL 的大型庫，它是用於基本程式設計資料結構和函式（如列表、堆疊、陣列等）的 C++ 模板的集合。這允許更短的程式碼和更快的編碼。它是一個迭代器庫，以及容器類。例如，Std::min 用於確定提供給它的數字是最小的。如果有多個，則返回第一個。

// C++ 程式演示 min() 函式的使用；
include <iostream>   
using namespace std;   
// Driver Code   
int main()   
{   
    double a = 12.123;   
    double b = 12.456;   
    // 列印兩個數字的最小值；
    cout << min(a, b);   
  
    return 0;   
}

更快：就效能而言，C/C++ 是最快的可用程式語言。機器程式碼必須從 C++ 原始碼建立。另一方面，Python 使用另一種方法來分析資料。程式碼編譯通常比解釋更快。

下面是一個示例程式，展示瞭如何使用clock()函式來測量執行時間：

//用於測量執行情況的 C++ 程式   
include <iostream>  
include <algorithm> // Required for using STL functions like min_element  
include <vector>    // Required for using STL vector  
using namespace std;  
// 查詢容器中最小元素的模板函式  
template <typename T>  
T findMinimum(const T &container) {  
   // 使用STL函式min_element查詢最小元素  
    return *min_element(container.begin(), container.end());  
}  
int main() {  
   // 整數示例  
    vector<int> intVector = {5, 2, 8, 1, 7};  
    int minInt = findMinimum(intVector);  
    cout << "Minimum integer: " << minInt << endl;  
        // double示例  
    vector<double> doubleVector = {3.14, 1.1, 7.5, 2.0, 5.6};  
    double minDouble = findMinimum(doubleVector);  
    cout << "Minimum double: " << minDouble << endl;  
    return 0;  
}

在本例中，我們定義了一個模板函式 findMinimum，該函式接收一個容器（如向量或陣列），並使用 STL 中的 min_element 函式查詢最小元素。
主函式演示了該模板函式在整型向量和雙型向量中的使用。
向量是 STL 的一部分，用於輕鬆建立動態陣列。begin() 和 end() 函式用於指定 min_element 的範圍。
這段程式碼展示了 C++ 的簡潔性和靈活性，它允許同一函式使用模板處理不同的資料型別，並利用 STL 實現高效簡潔的程式碼。

簡單的結構：用 C++ 編寫程式碼要比 Java 簡單得多，因為它是一種更簡單的語言，更類似於低階語言。此外，這還簡化、最佳化並加快了 C++ 程式碼的生成過程（也就是說，與 Java 不同，程式碼不需要先從位元組碼轉換為機器碼）。

使用廣泛：由於 C++ 的速度通常比 Java 和 Python 快，而且可以使用大多數資源，因此全球 75% 的程式設計師認為 C++ 是競爭性程式設計的最佳選擇。

// 演示模板    的 C++ 程式；
include <iostream>   
using namespace std;   
// 通用函式，用於查詢 2 種資料型別的最小值  
//；
template <typename T>   
T Min(T x, T y)   
{   
    return (x < y) ? x : y;   
}   
// Driver Code   
int main()   
{   
    cout << Min(7, 3) << endl;   
    cout << Min('z', 'a') << endl;   
    return 0;   
}

程式碼片段使用片段可以輕鬆地將常用函式或程式碼納入較長的程式碼部分。程式設計師可以將程式碼儲存為片段，然後將片段拖放到需要的地方，這樣就比重複建立相同的程式碼省時省力。程式設計師和網路開發人員還可以使用程式碼片段對經常出現的程式碼部分進行分類，從而簡化開發環境。它還能加快編碼速度，有助於編碼競賽等。

指標在C++中的應用
指標是 C++ 的重要元素，可實現複雜的記憶體操作和動態資源分配。本質上，指標是一個變數，它儲存另一個變數的記憶體位置，從而可以立即訪問和更改計算機和記憶體中儲存的資訊。

C++ 程式設計師透過指標自動分配和釋放記憶體的能力是有效利用記憶體的關鍵組成部分。
指標通常用於與外部庫或裝置互動、分配動態記憶體和運算元組等任務。
它們對於最佳化程式生產力和構建複雜的資料結構是必要的。

儘管指標管理有潛在的好處，但記憶體洩漏和分段錯誤仍然存在；因此，必須持續監控記憶體的處理。

它具有以下語法：

資料型別* 指標名稱； // 指標宣告的語法

下面是虛擬碼：

include <iostream>  
int 主函式 () {  
    // 宣告和初始化  
    int * 指標；  // 整型指標的宣告  
    整數 項= 10；  
    指標= &item;  // 初始化：指標現在儲存 x 的記憶體地址  
    // 訪問專案  
    int  y = *指標；  // 解除引用：y 現在儲存指標指向的記憶體地址處的值  
    // 輸出  
    std::cout <<  "專案值："  << item << std::endl;  
    std::cout <<  "指標指向的記憶體地址處的值："  << y << std::endl;  
    返回 0；  
}

真正的C++程式碼：

include <iostream>  
int main () {  
 // 宣告和初始化  
    int* pointer; // Declaration of an integer pointer  
    int item = 10;  
    pointer = &item; // Initialization: pointer now holds the memory address of x  
 // 訪問專案  
    int y = *pointer; // Dereferencing: y now holds the value at the memory address pointed by the pointer  
   // 輸出  
    std::cout << "Value of item: " << item << std::endl;  
    std::cout << "Value at the memory address pointed by pointer: " << y << std::endl;  
    return 0;  
}

程式碼執行輸出：

Value of x: 10
Value at the memory address pointed by pointer: 10

在 C++ 中，指標有多種應用，可用於高效靈活地運算元據、管理記憶體和改程序序。 C++ 中指標最流行的用途如下：

1.動態記憶體項分配：
使用指標的動態記憶體項分配可以在編譯時構造未知維度的資料結構。當使用值連結列表和陣列元素與程式執行期間可能具有可變大小的資料結構進行互動時，它非常有用。

dy ArrayItem; delete [] // 重新分配儲存物件，以防止記憶體洩露；

2. 接受函式引數：
指標用於傳遞基於函式的變數。它使函式能夠直接更改透過它們提供的變數的值。

empty change item (int* pointer) such that *pointer = 50; // 在記憶體專案地址中專案引用指向的位置調整專案；
int item = 10;   
int* pointer = &item;   
int main ()  
    change item by Pointer;

語法中的物件已透過使用指標進行了更改。

3. 指標和陣列項：
指標提供了訪問和修改陣列元素的有效方法。表遍歷、表操作其他表以及動態表分配都可以透過此專案實現。

int * p = numbers；  int numbers[] = {1, 2, 3, 4, 5}  
// 利用引用訪問陣列項元素 for (int i = 0; i < 5; ++i)

4.資料結構和連結串列
在建立動態資料結構（如連結串列）時，指標是必不可少的。在連結串列中，每個元素都按預定順序指向其後的元素。它有助於高效地新增和檢索元素。

struct Object {int data; Object* next}; // Creating an interconnected list  
* Head = new Object {1, nopointer};   
Head->next = new Object {2};   
Head->next->next = new Object {3};

5.指標運算
指標透過實現指標運算，可以有效地遍歷記憶體項。這在處理陣列或大塊記憶體時尤其有利。

{10, 20, 30, 40, 50} is the numerical value of int array item []; int* pointer = array item; // 透過指標運算訪問陣列項的元件。

6.檔案轉換：
檔案處理利用指標來讀寫檔案資訊。該元件允許對檔案內容進行處理，並有助於有效管理資料。

FILE* file pointer = fopen ("instance.txt", "r"); //使用檔案指標的位置來讀取或寫入資料  ；
fclose (file pointer); void add (int a, int b) { std::cout \\ "Sum: " \\ a + b \\ std::endl; }  
int main ()   
{  
 void (*funcPointer) (int, int) = add; funcPointer (5, 10); //

使用函式指標呼叫add函式

 return 0;
}

指標是用於跨不同上下文的穿針引線的控制代碼。

C++ 的指標實現對於各種計算機應用程式來說都是適應性強且至關重要的。指標陣列可以成功處理資訊和可程式設計記憶體項分配，從而幫助開發人員最佳化記憶體項管理。在一些應用程式中，包括動態記憶體項分配、函式引數傳遞、陣列項操作以及連結串列等資料結構的建立，指標提供了靈活性並最佳化了資源消耗。由於指標而產生的自適應記憶體項分配使得為執行時定義的資料構造結構變得更加簡單，從而促進了更具響應性和適應性的程式。

C++中使用棧的佇列
將堆疊資料結構實現為佇列，低階資料結構是壓入（新增元素）和彈出（刪除元素）操作。

堆疊是後進先出（LIFO）資料結構，而佇列是 FIFO （先進先出）資料結構。堆疊彈出頂部的元素並將新元素推入堆疊的頂部。另一方面，佇列在底部入隊（插入）元素，同時從頂部出隊（刪除）元素。

使用堆疊資料結構，有兩種方法來實現佇列。

一種方法使用一個堆疊，
而另一種方法則使用兩個堆疊。

使用兩個堆疊：
此方法確保最舊的插入元素始終位於 stack1 的頂部，以便 deQueue 操作只需從 stack1 中彈出。堆疊 2 用於將元素定位在堆疊 1 的頂部。
入隊（x）：

當 stack1 不為空時，將 stack1 中的所有內容推送到 stack2。
將 x 推入 stack1。
將所有內容推回 stack1。

出隊（x）：

如果 stack1 為空，則顯示錯誤訊息。
從 stack1 中彈出一個專案並將其返回。

include <bits/stdc++.h>   
using namespace std;   
struct Queue {   
stack<int> stack1, stack2;   
void enqueue(int x)   
{   
while (!stack1.empty()) {   
stack2.push(stack1.top());   
stack1.pop();   
}   
stack1.push(x);   
while (!stack2.empty()) {   
stack1.push(stack2.top());   
stack2.pop();   
}   
}   
int dequeue()   
{   
if (stack1.empty()) {   
cout << "queue is Empty";   
exit(0);   
}   
int x = stack1.top();   
stack1.pop();   
return x;   
}   
};   
int main()   
{   
Queue q;   
q.enqueue(7);   
q.enqueue(9);   
q.enqueue(8);   
cout << q.dequeue() << endl;   
cout << q.dequeue() << endl;   
cout << q.dequeue() << endl;   
return 0;   
}

使用一個堆疊：
佇列也可以僅使用一個使用者堆疊來實現，並且它使用遞迴。
入隊（x）：

將 x 推入 stack_。

出隊（x）：

如果 stack_ 為空，則顯示錯誤訊息。
如果 stack_ 只有一個元素，則返回它。
遞迴地將每個專案從 stack_ 中彈出，將其放入名為 ret 的變數中，將其推回 stack_，然後返回 ret。

Dequeue() 的第三步確保始終返回要彈出的最後一項。當stack_中只剩下一項時，遞迴停止，在 dequeue() 中返回 stack_ 中的最後一個元素，並將剩餘的項推回到 stack_ 中。

include <bits/stdc++.h>   
using namespace std;   
struct Queue {   
stack<int> stack_;   
void enqueue(int x)   
{   
stack_.push(x);   
}   
int dequeue()   
{   
if (stack_.empty()) {   
cout << "Queue is empty" << endl;;   
exit(0);   
}   
int x = stack_.top();   
stack_.pop();   
if (stack_.empty())   
return x;   
int ret = dequeue();   
stack_.push(x);   
return ret;   
}   
};   
int main()   
{   
Queue q;   
q.enqueue(7);   
q.enqueue(9);   
q.enqueue(8);   
cout << q.dequeue() << endl;   
cout << q.dequeue() << endl;   
cout << q.dequeue() << endl;   
return 0;   
}

在 C++ 中使用堆疊的佇列的好處
在 C++ 中使用兩個堆疊實現佇列有幾個優點，特別是在特定情況下的簡單性和效率方面。以下是一些好處：

簡單：實現起來並不太困難。有兩個堆疊：堆疊 1 用於入隊操作，堆疊 2 用於出隊操作。它可以促進程式碼的理解和維護。
出隊函式的有效性：從攤銷的意義上來說，出隊操作的時間複雜度恆定為 O(1)。原因是當 stack2 為空時，元件才會從 stack1 傳輸到 stack2。一旦傳輸，stack2 可以多次有效地出隊，直到它再次變空，此時啟動另一次傳輸。
空間效率：O(n)是空間複雜度，其中 n 是佇列中元素的數量。這是因為每個元素只儲存在 stack1 或 stack2 中。透過在其他佇列實現中使用更多資料結構可以實現更高的空間複雜度。
靈活性：此方法允許您選擇您選擇的基礎資料結構（堆疊）。在堆疊比其他資料結構更有意義或更有效的情況下，它可能會很有用。
入隊操作：入隊操作的時間複雜度為O(1)，因為它們直接將元素壓入 stack1。但是，在入隊操作頻繁且出隊操作不頻繁的情況下，其他資料結構（例如連結串列或動態陣列）可能會更有效。

C++ 中的比較器
C++ 中的比較器在對陣列、向量和陣列等不同資料結構的元素進行排序和比較方面發揮著重要作用。它定義了元素按特定順序排列的標準。在 C++ 中，比較器通常與需要自定義排序的排序演算法或資料結構一起使用。

比較器是一個函式或函式（函式物件），它接受兩個引數並返回一個布林值，指示第一個引數是否應被視為小於第二個引數。比較函式定義了比較元素的規則，它允許您配置排序行為。比較器最常見的用途之一是與標準模板庫 (STL) 演算法結合使用，例如std::sort，它允許根據提供的比較器對元素進行排序。瞭解比較器的工作原理及其實現方式對於處理複雜資料結構的 C++ 程式設計師至關重要。

比較基礎：比較器通常將自身附加到特定簽名，作為二進位制函式或作為操作函式。對於二元函式，它需要兩個引數，通常表示為“a”和“b”，並返回一個布林值，指示“a”是否小於“b”。

bool compare (int a, int b) {  
 return a < b; // Example comparator for integers  
}

函式物件作為引用函式：在 C++ 中，函式物件（函式）通常比引用函式更受歡迎。函式物件提供了更大的靈活性，並在需要時節省了額外的空間。下面是一個用作比較函式的示例：

struct CustomComparator {  
 bool operator ()(int a, int b) const {  
 return a < b; // Example functor for integers  
   
};

在 STL 演算法中使用比較：STL 演算法（如 std::排序）接受自定義比較器。要在 std::sort 中使用比較器，請將其指定為第三個引數：

include <algorithm>  
include <vector>  
int main() {  
 std::vector<int> numbers = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};  
 //將函式用作比較器  ；
 std::sort(numbers.begin(), numbers.end(), compare);  
 // Using a function as a comparator  
 CustomComparator comparator;  
 std::sort(numbers.begin(), numbers.end(), comparator);  
 return 0;  
}

自定義排序順序：比較器可根據特定條件自定義排序順序。例如，可以調整比較邏輯，以降序對元素進行排序。

struct DescendingComparator {  
 bool operator()(int a, int b) const {  
 return a > b;  
 }  
};  
  
// ..  
std::sort(numbers.begin(), numbers.end(), DescendingComparator());

用於複雜物件的比較器在處理使用者定義的型別或自定義物件時，自定義比較器變得至關重要。例如，根據特定屬性對自定義物件向量進行排序。

struct Person {  
 std::string name;  
 int age;  
};  
struct AgeComparator {  
 bool operator()(const Person& a, const Person& b) const {  
 return a.age < b.age;  
 }  
};  
// ...  
std::vector<Person> people = /* populate the vector */<font><i>;  
std::sort(people.begin(), people.end(), AgeComparator());

比較器的意義
C++ 中比較的重要性：

自定義排序： C++ 中的比較器在自定義各種資料結構的排序行為方面發揮著關鍵作用。定義比較元素的特定標準的能力使開發人員能夠根據自己的個人需求調整排序演算法。在處理複雜的資料型別或物件時，這種自定義尤其重要，因為預設排序可能無法提供所需的結果。
靈活性和適應性：運算元提供靈活性和適應性，這在現實程式設計場景中極其重要。可以定義自定義比較邏輯的開發人員可以調整排序演算法來處理不同的用例。這種靈活性在處理使用者定義的型別時尤其有價值，允許根據特定屬性或複雜條件進行排序。
與 STL 演算法整合：比較器與標準模板庫 (STL) 演算法的無縫整合提高了程式碼的可重用性和可讀性。std::sort、std::max_element等演算法僅接受自定義比較器作為引數，從而可以輕鬆實現自定義排序規則，而無需更改底層演算法。這種整合簡化了開發過程並促進了程式碼庫之間的一致性。
支援複雜的資料結構：在處理表、對映或優先順序佇列等高階資料結構時，比較器變得至關重要。這些資料結構通常基於明確定義的順序，以確保高效執行。自定義比較器允許開發人員處理複雜的場景，並確保這些高階資料結構中的元素根據特定標準進行排序。
排序邏輯封裝：比較器封裝排序邏輯，促進程式碼模組化和可維護。透過將比較標準封裝在自定義函式或函式中，開發人員可以輕鬆替換或更改比較器，而不影響整體排序演算法。這種封裝改進了程式碼組織，使得隨著專案需求的變化更容易管理和開發。
提高演算法效能：在預設排序機制不理想或不切實際的情況下，自定義比較器可以提高演算法效能。例如，使用自定義比較器可以有效地實現按降序對元素進行排序、對某些屬性進行優先順序排序或考慮不尋常的排序要求，從而生成更流暢、更高效的程式碼。

透過一個例子來說明C++中Comparator的使用。

include <iostream>  
include <vector>  
include <algorithm>  
<font>// Define a custom data type  <i>
struct Person {  
 std::string name;  
 int age;  
  
 // Constructor  <i>
 Person(const std::string& n, int a) : name(n), age(a) {}  
 //按年齡升序排序的比較器函式  ；<i>
 static bool compareByAge(const Person& a, const Person& b) {  
 return a.age < b.age;  
 }  
 // 按名稱升序排序的比較器函式  ；<i>
 static bool compareByName(const Person& a, const Person& b) {  
 return a.name < b.name;  
 }  
};  
int main() {  
 //建立人物物件向量 ；<i>
 std::vector<Person> people = {  
 {"John", 30},  
 {"Alice", 25},  
 {"Bob", 35},  
 {"Charlie", 28}  
 };  
 //使用 compareByAge 比較器按年齡對向量進行排序；<i>
 std::sort(people.begin(), people.end(), Person::compareByAge);  
  
 // Display the sorted vector  <i>
 std::cout << "Sorted by age:\n";  
 for (const auto& person : people) {  
 std::cout << person.name << " - " << person.age << " years old\n";  
 }  
 // 使用 compareByName 比較器按名稱對向量排序；<i>
 std::sort(people.begin(), people.end(), Person::compareByName);  
  
 // 顯示排序後的向量<i>
 std::cout << "\nSorted by name:\n";  
 for (const auto& person : people) {  
 std::cout << person.name << " - " << person.age << " years old\n";  
 }  
 return 0;  
}

輸出：

Sorted by age:
Alice - 25 years old
Charlie - 28 years old
John - 30 years old
Bob - 35 years old

Sorted by name:
Alice - 25 years old
Bob - 35 years old
Charlie - 28 years old
John - 30 years old

C++ 中比較器的重要性在於它們能夠克服預設排序行為的限制。隨著開發人員努力解決日益複雜的程式設計問題，設定基準成為一項寶貴的資產。定義自定義排序標準的靈活性使開發人員能夠建立精確匹配其應用程式和要求的解決方案。

比較器的特點之一是與 STL 演算法的無縫整合。這種協同作用使得在容器中實現自定義排序邏輯變得容易，從而提高程式碼一致性並減少冗餘。將比較器與std::sort等演算法結合使用的能力提高了 C++ 程式碼的表達能力，使程式設計師能夠清晰、簡潔地表達自己的意圖。

在資料結構領域，比較器可以對陣列、對映和其他容器中的元素進行有效排序。在預設順序可能無法捕捉元素之間的細微差別的情況下，這一點尤其重要。自定義比較器透過提供一種表達複雜比較標準的方法來提供解決方案，同時確保資料結構的行為精確。此外，比較器鼓勵排序邏輯的封裝，促進模組化和可維護的程式碼庫。這種封裝允許開發人員隔離比較標準，從而可以輕鬆更新或修改比較器，而不會影響整體演算法。

隨著技術的進步和軟體專案變得越來越複雜，比較器的作用在 C++ 中仍然很重要。無論是處理數值資料、使用者定義型別還是複雜的資料結構，使用比較器自定義排序行為都允許開發人員導航複雜的程式設計場景。

總之，比較器證明了 C++ 語言的適應性和可擴充套件性。它們的重要性不僅在於它們在排序元素方面的直接效用，還在於它們對程式碼組織、演算法效率和整體程式設計靈活性的貢獻。隨著 C++ 繼續成為各種應用程式的流行語言，對比較器的深入理解成為任何經驗豐富的 C++ 程式設計師工具箱中的寶貴工具。

用於迭代快速排序的 C++ 程式
一種以其實用效率和功效而聞名的流行排序演算法稱為“快速排序”。儘管快速排序的遞迴變體使用得更頻繁，但也可以實現迭代版本來避免與遞迴函式呼叫相關的開銷。這種迭代方法使用堆疊來管理陣列中需要排序的分割槽。

快速排序的基本原理是根據陣列剩餘元素比主元的大小將其分成兩個子陣列，然後從陣列中選擇一個主元元素。之後，子陣列迭代地執行此過程，從而對整個陣列進行排序。

分割槽函式選擇一個主元並對陣列進行分割槽，是在程式開始時定義的。“iterativeQuickSort”函式使用堆疊來跟蹤需要排序的子陣列。它在不斷從堆疊中刪除子陣列並使用分割槽函式對其進行分割槽後，將結果子陣列推回堆疊。重複此操作直到堆疊為空，以確保每個元素都正確排序。

該程式使用示例陣列來展示該功能。該陣列在排序過程之前和之後都會顯示，清楚地顯示元素如何使用迭代快速排序方法按升序排列。

透過理解並將該演算法的迭代版本付諸實踐，開發人員可以體會到快速排序的效率，並學習如何針對實際設定最佳化排序演算法。演算法設計中遞迴和迭代之間的權衡透過迭代方法對顯式堆疊的使用而得以體現。

迭代快速排序演算法

開始
選擇任意元素作為樞軸。
如果元素小於樞軸。
與索引處的元素交換。
增量索引。
將所有小於樞軸的元素推到左側。
將所有大於元素的元素推到右側。
將最右邊的元素與索引處的元素交換。
返回索引。
列印排序陣列。
停止

複雜度分析：

時間複雜度：

快速排序的平均時間複雜度和最佳情況時間複雜度為O(n log n) ，這使得它對於大型資料集非常有效。另一方面，如果主元選擇反覆導致分割槽不平衡，在最壞的情況下，時間複雜度可能會降至O(n^2)。遞迴和迭代版本保留相同的時間複雜度屬性。

空間複雜度：

它的記憶體需求與輸入量不成正比，因為快速排序是一種就地排序演算法。迭代版本可能比遞迴版本使用更少的記憶體，因為它使用顯式堆疊。

include <iostream>  
include <stack>  
using namespace std;  
<font>//用於分割陣列並返回樞軸元素索引的函式  ；<i>
int partition(int arr[], int low, int high)   
{  
 int pivot = arr[high];  
 int i = low - 1;  
 for (int j = low; j < high; ++j)   
 {  
 if (arr[j] <= pivot)  
 {  
 ++i;  
 swap(arr[i], arr[j]);  
 }  
 }  
 swap(arr[i + 1], arr[high]);  
 return i + 1;  
}  
//執行迭代快速排序的函式  ；<i>
void iterativeQuickSort(int arr[], int low, int high)  
{  
 stack<pair<int, int>> stk;  
 stk.push({low, high});  
 while (!stk.empty())   
 {  
 int start = stk.top().first;  
 int end = stk.top().second;  
 stk.pop();  
 int pivotIndex = partition(arr, start, end);  
 if (pivotIndex - 1 > start)  
 {  
 stk.push({start, pivotIndex - 1});  
 }  
 if (pivotIndex + 1 < end)  
 {  
 stk.push({pivotIndex + 1, end});  
 }  
 }  
}  
//用於列印陣列  ；<i>
void printArray(int arr[], int size)   
{  
 for (int i = 0; i < size; ++i)  
 {  
 cout << arr[i] << " ";  
 }  
 cout << endl;  
}  
int main()  
{  
 int arr[] = {12, 4, 5, 6, 7, 3, 1, 15};  
 int size = sizeof(arr) / sizeof(arr[0]);  
 cout << "Original array: ";  
 printArray(arr, size);  
 iterativeQuickSort(arr, 0, size - 1);  
 cout << "Sorted array: ";  
 printArray(arr, size);  
 return 0;  
}

輸出：

Original array: 12 4 5 6 7 3 1 15 
Sorted array: 1 3 4 5 6 7 12 15

在本例中，程式包含 C++ 的典型指令。包含 <iostream> 標頭檔案以對輸入/輸出進行操作，包含 <stack> 以使用堆疊資料結構。
這就是分割槽函式的工作原理。它的引數是低索引（low）、高索引（high）和一個陣列（arr）。在選擇位於高索引處的元素作為樞軸後，函式會重新排列陣列元素，使小於或等於樞軸的元素位於左側，而大於樞軸的元素位於右側。分割後，返回樞軸元素的索引。
這就是所謂的迭代快速排序（iterativeQuickSort）函式。需要低索引（low）、高索引（high）和一個陣列（arr）。需要排序的子陣列使用堆疊 (stk) 跟蹤。它使用 while 迴圈迭代處理子陣列。在每次迭代開始時，它會從堆疊中移除一個子陣列，使用 partition 函式對其進行分割，如果子陣列已經排序，則將其推回堆疊。
之後，我們使用 printArray 函式，其引數是陣列 (arr) 和大小 (size)。它將陣列元素輸出到標準輸出。
main() 函式是主函式，也是程式的入口。首先初始化一個陣列，然後使用 printArray 函式顯示原始陣列，使用 iterativeQuickSort 方法對陣列進行排序，最後再次顯示排序後的陣列。

C++語言菜鳥快速入門

相關文章