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 */;  
std::sort(people.begin(), people.end(), AgeComparator());

比较器的意义
C++ 中比较的重要性：

自定义排序： C++ 中的比较器在自定义各种数据结构的排序行为方面发挥着关键作用。定义比较元素的特定标准的能力使开发人员能够根据自己的个人需求调整排序算法。在处理复杂的数据类型或对象时，这种自定义尤其重要，因为默认排序可能无法提供所需的结果。
灵活性和适应性：算子提供灵活性和适应性，这在现实编程场景中极其重要。可以定义自定义比较逻辑的开发人员可以调整排序算法来处理不同的用例。这种灵活性在处理用户定义的类型时尤其有价值，允许根据特定属性或复杂条件进行排序。
与 STL 算法集成：比较器与标准模板库 (STL) 算法的无缝集成提高了代码的可重用性和可读性。std::sort、std::max_element等算法仅接受自定义比较器作为参数，从而可以轻松实现自定义排序规则，而无需更改底层算法。这种集成简化了开发过程并促进了代码库之间的一致性。
支持复杂的数据结构：在处理表、映射或优先级队列等高级数据结构时，比较器变得至关重要。这些数据结构通常基于明确定义的顺序，以确保高效运行。自定义比较器允许开发人员处理复杂的场景，并确保这些高级数据结构中的元素根据特定标准进行排序。
排序逻辑封装：比较器封装排序逻辑，促进代码模块化和可维护。通过将比较标准封装在自定义函数或函数中，开发人员可以轻松替换或更改比较器，而不影响整体排序算法。这种封装改进了代码组织，使得随着项目需求的变化更容易管理和开发。
提高算法性能：在默认排序机制不理想或不切实际的情况下，自定义比较器可以提高算法性能。例如，使用自定义比较器可以有效地实现按降序对元素进行排序、对某些属性进行优先级排序或考虑不寻常的排序要求，从而生成更流畅、更高效的代码。

通过一个例子来说明C++中Comparator的使用。

include <iostream>  
include <vector>  
include <algorithm>  
// Define a custom data type  
struct Person {  
 std::string name;  
 int age;  
  
 // Constructor  
 Person(const std::string& n, int a) : name(n), age(a) {}  
 //按年龄升序排序的比较器函数  ；
 static bool compareByAge(const Person& a, const Person& b) {  
 return a.age < b.age;  
 }  
 // 按名称升序排序的比较器函数  ；
 static bool compareByName(const Person& a, const Person& b) {  
 return a.name < b.name;  
 }  
};  
int main() {  
 //创建人物对象矢量 ；
 std::vector<Person> people = {  
 {"John", 30},  
 {"Alice", 25},  
 {"Bob", 35},  
 {"Charlie", 28}  
 };  
 //使用 compareByAge 比较器按年龄对向量进行排序；
 std::sort(people.begin(), people.end(), Person::compareByAge);  
  
 // Display the sorted vector  
 std::cout << "Sorted by age:\n";  
 for (const auto& person : people) {  
 std::cout << person.name << " - " << person.age << " years old\n";  
 }  
 // 使用 compareByName 比较器按名称对向量排序；
 std::sort(people.begin(), people.end(), Person::compareByName);  
  
 // 显示排序后的矢量
 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;  
//用于分割数组并返回枢轴元素索引的函数  ；
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;  
}  
//执行迭代快速排序的函数  ；
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});  
 }  
 }  
}  
//用于打印数组  ；
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 方法对数组进行排序，最后再次显示排序后的数组。