C++ STL Blog Posts

dsa/intermediate/Graph_traversal.md

@@ -16,7 +16,7 @@ tags:
   - java
   - programming
   - tutorial
-sidebar_position: 5
+sidebar_position: 3
 ---
 ## What is Graph Data Structure
 Graph Data Structure is a collection of vertices connected by edges. The vertices(V) are also referred as nodes and lines connecting any two nodes are called edges(E). A graph is denoted by G(V,E).

dsa/intermediate/_category_.json

@@ -5,4 +5,4 @@
       "type": "generated-index",
       "description": "Learn the intermediate of the Data Structures."
     }
-  }
+}

dsa/intermediate/binary_tree.md

@@ -13,7 +13,7 @@ tags:
   - java
   - programming
   - tutorial
-sidebar_position: 5
+sidebar_position: 2
 ---
 In this tutorial we will explore one of the fundamental data structure in computer science: Binary Tree 
 # What is a Binary Tree?

dsa/intermediate/cpp_stl/_category_.json

@@ -0,0 +1,8 @@
+{
+    "label": "cpp-stl",
+    "position": 2,
+    "link": {
+      "type": "generated-index",
+      "description": "Learn everything from the basics to the advanced topics that make up the C++ Standard Template Library."
+    }
+}

dsa/intermediate/cpp_stl/cpp_find.md

@@ -0,0 +1,285 @@
+---
+id: cpp-find
+title: The Find Algorithm in C++
+sidebar_label: CPP STL
+tags:
+  - dsa
+  - data-structures
+  - cpp
+  - intermediate
+  - stl
+  - standard template library
+  - cpp stl
+  - programming
+  - tutorial
+  - find algorithm
+  - cpp find
+sidebar_position: 7
+---
+
+# Mastering the `find` Algorithm in C++: A Comprehensive Guide
+
+Hello, C++ enthusiasts! Today, we’re diving into one of the most fundamental and versatile components of the C++ Standard Library: the `find` algorithm. If you're looking to enhance your understanding and utilization of searching in C++, you're in the right place. This guide will cover everything you need to know about the `find` algorithm, from basic usage to advanced features, complete with examples and practical applications.
+
+## What is the `find` Algorithm?
+
+The `find` algorithm is a built-in function in the C++ Standard Library that allows you to search for a specific element in a range, typically specified by two iterators. It is part of the `<algorithm>` header and provides a straightforward way to locate elements within containers like vectors, lists, and arrays.
+
+### Why Use the `find` Algorithm?
+
+1. **Efficiency**: The find algorithm is optimized for performance and typically runs in O(n) time complexity.
+2. **Convenience**: It simplifies the search process and reduces the amount of boilerplate code needed to implement searching.
+3. **Flexibility**: The find algorithm can be used with various types of containers and custom comparison functions.
+
+## Basics of the `find` Algorithm
+
+Let’s start with the basics of using the `find` algorithm in C++.
+
+### Including the Header
+
+To use the `find` algorithm, you need to include the `<algorithm>` header.
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <vector>
+```
+
+### Basic Usage
+
+The `find` algorithm requires three parameters: two iterators specifying the range to search within and the value to search for.
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> numbers = {1, 2, 3, 4, 5};
+    auto it = std::find(numbers.begin(), numbers.end(), 3);
+
+    if (it != numbers.end()) {
+        std::cout << "Element found: " << *it << std::endl;
+    } else {
+        std::cout << "Element not found." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+### Searching in Different Containers
+
+You can use the `find` algorithm with various types of containers, such as vectors, lists, and arrays.
+
+Example with a List:
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <list>
+
+int main() {
+    std::list<int> numbers = {1, 2, 3, 4, 5};
+    auto it = std::find(numbers.begin(), numbers.end(), 3);
+
+    if (it != numbers.end()) {
+        std::cout << "Element found: " << *it << std::endl;
+    } else {
+        std::cout << "Element not found." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+## Advanced Features
+
+Now that we've covered the basics, let's explore some advanced features and techniques for using the `find` algorithm in C++.
+
+### Using `find` with Custom Data Types
+
+You can use the `find` algorithm to search for elements in containers of custom data types by providing a suitable comparison function.
+
+Example with a Custom Data Type:
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <vector>
+#include <string>
+
+struct Person {
+    std::string name;
+    int age;
+
+    bool operator==(const Person &other) const {
+        return name == other.name && age == other.age;
+    }
+};
+
+int main() {
+    std::vector<Person> people = {{"Alice", 30}, {"Bob", 25}, {"Charlie", 35}};
+    Person target = {"Bob", 25};
+    auto it = std::find(people.begin(), people.end(), target);
+
+    if (it != people.end()) {
+        std::cout << "Person found: " << it->name << ", " << it->age << std::endl;
+    } else {
+        std::cout << "Person not found." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+### Using `find_if` for More Complex Searches
+
+When you need more complex search criteria, you can use the `find_if` algorithm, which allows you to specify a predicate function.
+
+Example with `find_if`:
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> numbers = {1, 2, 3, 4, 5};
+    auto it = std::find_if(numbers.begin(), numbers.end(), [](int x) {
+        return x > 3;
+    });
+
+    if (it != numbers.end()) {
+        std::cout << "First element greater than 3: " << *it << std::endl;
+    } else {
+        std::cout << "No elements greater than 3 found." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+### Using `find_if_not` for Negative Searches
+
+The `find_if_not` algorithm finds the first element that does not satisfy a given predicate.
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> numbers = {1, 2, 3, 4, 5};
+    auto it = std::find_if_not(numbers.begin(), numbers.end(), [](int x) {
+        return x < 3;
+    });
+
+    if (it != numbers.end()) {
+        std::cout << "First element not less than 3: " << *it << std::endl;
+    } else {
+        std::cout << "All elements are less than 3." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+## Practical Applications of the find Algorithm
+
+The `find` algorithm is not just a theoretical construct; it is immensely practical and can be used in various scenarios to solve real-world problems.
+
+### Problem 1: Finding an Element in a Vector
+
+You have a vector of integers, and you want to find a specific element.
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+int main() {
+    std::vector<int> numbers = {1, 2, 3, 4, 5};
+    int target = 4;
+    auto it = std::find(numbers.begin(), numbers.end(), target);
+
+    if (it != numbers.end()) {
+        std::cout << "Element " << target << " found at index " << std::distance(numbers.begin(), it) << std::endl;
+    } else {
+        std::cout << "Element " << target << " not found." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+### Problem 2: Finding a String in a List
+
+You have a list of strings, and you want to find a specific string.
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <list>
+#include <string>
+
+int main() {
+    std::list<std::string> names = {"Alice", "Bob", "Charlie"};
+    std::string target = "Bob";
+    auto it = std::find(names.begin(), names.end(), target);
+
+    if (it != names.end()) {
+        std::cout << "Name " << target << " found." << std::endl;
+    } else {
+        std::cout << "Name " << target << " not found." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+### Problem 3: Finding a Custom Object in a Set
+
+You have a set of custom objects, and you want to find a specific object based on a member variable.
+
+```cpp
+#include <algorithm>
+#include <iostream>
+#include <set>
+#include <string>
+
+struct Book {
+    std::string title;
+    int year;
+
+    bool operator<(const Book &other) const {
+        return title < other.title;
+    }
+};
+
+bool compareByTitle(const Book &a, const Book &b) {
+    return a.title == b.title;
+}
+
+int main() {
+    std::set<Book> books = {{"C++ Primer", 2012}, {"Effective C++", 2005}, {"The C++ Programming Language", 2013}};
+    Book target = {"Effective C++", 2005};
+    auto it = std::find_if(books.begin(), books.end(), [&](const Book &b) {
+        return compareByTitle(b, target);
+    });
+
+    if (it != books.end()) {
+        std::cout << "Book found: " << it->title << ", " << it->year << std::endl;
+    } else {
+        std::cout << "Book not found." << std::endl;
+    }
+
+    return 0;
+}
+```
+
+## In Conclusion
+
+The `find` algorithm is a powerful and versatile tool in the C++ Standard Library, offering efficient and flexible searching capabilities. By mastering the `find` algorithm, you can write more efficient, readable, and maintainable code. Whether you're searching for simple data types, complex objects, or using custom comparison functions, the `find` algorithm is the go-to solution. <br />
+
+So, dive into the world of searching, experiment with the `find` algorithm, and unlock the full potential of your C++ programming skills. Happy coding, and may your searches always be successful!