backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-05-04 04:24:45 +08:00
Code Issues Projects Releases Wiki Activity

fix add <cstdint> to datastructures/list_array>cpp

Browse Source
This commit is contained in:
realstealthninja
2024-08-31 11:16:07 +05:30
parent 11d2437158
commit ef59b45129
1 changed files with 182 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

352
data_structures/list_array.cpp
View File

@@ -4,17 +4,20 @@
* *
* @details * @details
* The list_array is the implementation of list represented using array. * The list_array is the implementation of list represented using array.
* We can perform basic CRUD operations as well as other operations like sorting etc. * We can perform basic CRUD operations as well as other operations like sorting
* etc.
* *
* ### Algorithm * ### Algorithm
* It implements various method like insert, sort, search etc. efficiently. * It implements various method like insert, sort, search etc. efficiently.
* You can select the operation and methods will do the rest work for you. * You can select the operation and methods will do the rest work for you.
* You can insert element, sort them in order, search efficiently, delete values and print the list. * You can insert element, sort them in order, search efficiently, delete values
* and print the list.
*/ */
#include <iostream> /// for io operations #include <array> /// for std::array
#include <array> /// for std::array #include <cassert> /// for assert
#include <cassert> /// for assert #include <cstdint> /// for integral typedefs
#include <iostream> /// for io operations
/** /**
* @namespace data_structures * @namespace data_structures
@@ -23,181 +26,190 @@
namespace data_structures { namespace data_structures {
/** /**
* @namespace list_array * @namespace list_array
* @brief Functions for [Dynamic Array](https://en.wikipedia.org/wiki/Dynamic_array) algorithm * @brief Functions for [Dynamic
* Array](https://en.wikipedia.org/wiki/Dynamic_array) algorithm
*/ */
namespace list_array { namespace list_array {
/**
* @brief Structure of List with supporting methods.
*/
template <uint64_t N>
struct list {
std::array<uint64_t, N> data{}; // Array that implement list
uint64_t top = 0; // Pointer to the last element
bool isSorted = false; // indicator whether list is sorted or not
/** /**
* @brief Structure of List with supporting methods. * @brief Search an element in the list using binarySearch.
* @param dataArr list
* @param first pointer to the first element in the remaining list
* @param last pointer to the last element in the remaining list
* @param val element that will be searched
* @return index of element in the list if present else -1
*/ */
template <uint64_t N> uint64_t BinarySearch(const std::array<uint64_t, N> &dataArr,
struct list { const uint64_t &first, const uint64_t &last,
std::array<uint64_t, N> data{}; // Array that implement list const uint64_t &val) {
uint64_t top = 0; // Pointer to the last element // If both pointer cross each other means no element present in the list
bool isSorted = false; // indicator whether list is sorted or not // which is equal to the val
/** if (last < first) {
* @brief Search an element in the list using binarySearch.
* @param dataArr list
* @param first pointer to the first element in the remaining list
* @param last pointer to the last element in the remaining list
* @param val element that will be searched
* @return index of element in the list if present else -1
*/
uint64_t BinarySearch(const std::array<uint64_t, N> &dataArr, const uint64_t &first, const uint64_t &last,
const uint64_t &val) {
// If both pointer cross each other means no element present in the list which is equal to the val
if (last < first) {
return -1;
}
uint64_t mid = (first + last) / 2;
// check whether current mid pointer value is equal to element or not
if (dataArr[mid] == val)
return mid;
// if current mid value is greater than element we have to search in first half
else if (val < dataArr[mid])
return (BinarySearch(dataArr, first, mid - 1, val));
// if current mid value is greater than element we have to search in second half
else if (val > dataArr[mid])
return (BinarySearch(dataArr, mid + 1, last, val));
std::cerr << __func__ << ":" << __LINE__ << ": Undefined condition\n";
return -1; return -1;
} }
uint64_t mid = (first + last) / 2;
// check whether current mid pointer value is equal to element or not
if (dataArr[mid] == val)
return mid;
// if current mid value is greater than element we have to search in
// first half
else if (val < dataArr[mid])
return (BinarySearch(dataArr, first, mid - 1, val));
// if current mid value is greater than element we have to search in
// second half
else if (val > dataArr[mid])
return (BinarySearch(dataArr, mid + 1, last, val));
/** std::cerr << __func__ << ":" << __LINE__ << ": Undefined condition\n";
* @brief Search an element using linear search return -1;
* @param dataArr list }
* @param val element that will be searched
* @return index of element in the list if present else -1 /**
*/ * @brief Search an element using linear search
uint64_t LinearSearch(const std::array<uint64_t, N> &dataArr, const uint64_t &val) const { * @param dataArr list
// Going through each element in the list * @param val element that will be searched
for (uint64_t i = 0; i < top; i++) { * @return index of element in the list if present else -1
if (dataArr[i] == val) { */
return i; // element found at ith index uint64_t LinearSearch(const std::array<uint64_t, N> &dataArr,
const uint64_t &val) const {
// Going through each element in the list
for (uint64_t i = 0; i < top; i++) {
if (dataArr[i] == val) {
return i; // element found at ith index
}
}
// element is not present in the list
return -1;
}
/*
* @brief Parent function of binarySearch and linearSearch methods
* @param val element that will be searched
* @return index of element in the list if present else -1
*/
uint64_t search(const uint64_t &val) {
uint64_t pos; // pos variable to store index value of element.
// if list is sorted, binary search works efficiently else linear search
// is the only option
if (isSorted) {
pos = BinarySearch(data, 0, top - 1, val);
} else {
pos = LinearSearch(data, val);
}
// if index is equal to -1 means element does not present
// else print the index of that element
if (pos != -1) {
std::cout << "\nElement found at position : " << pos;
} else {
std::cout << "\nElement not found";
}
// return the index of element or -1.
return pos;
}
/**
* @brief Sort the list
* @returns void
*/
void sort() {
// Going through each element in the list
for (uint64_t i = 0; i < top; i++) {
uint64_t min_idx = i; // Initialize the min variable
for (uint64_t j = i + 1; j < top; j++) {
// check whether any element less than current min value
if (data[j] < data[min_idx]) {
min_idx = j; // update index accordingly
} }
} }
// element is not present in the list // swap min value and element at the ith index
return -1; std::swap(data[min_idx], data[i]);
} }
// mark isSorted variable as true
isSorted = true;
}
/* /**
* @brief Parent function of binarySearch and linearSearch methods * @brief Insert the new element in the list
* @param val element that will be searched * @param val element that will be inserted
* @return index of element in the list if present else -1 * @returns void
*/ */
uint64_t search(const uint64_t &val) { void insert(const uint64_t &val) {
uint64_t pos; // pos variable to store index value of element. // overflow check
// if list is sorted, binary search works efficiently else linear search is the only option if (top == N) {
if (isSorted) { std::cout << "\nOverflow";
pos = BinarySearch(data, 0, top - 1, val); return;
} else {
pos = LinearSearch(data, val);
}
// if index is equal to -1 means element does not present
// else print the index of that element
if (pos != -1) {
std::cout << "\nElement found at position : " << pos;
} else {
std::cout << "\nElement not found";
}
// return the index of element or -1.
return pos;
} }
// if list is not sorted, insert at the last
/** // otherwise place it to correct position
* @brief Sort the list if (!isSorted) {
* @returns void data[top] = val;
*/ top++;
void sort() { } else {
//Going through each element in the list uint64_t pos = 0; // Initialize the index variable
for (uint64_t i = 0; i < top; i++) { // Going through each element and find correct position for element
uint64_t min_idx = i; // Initialize the min variable for (uint64_t i = 0; i < top - 1; i++) {
for (uint64_t j = i + 1; j < top; j++) { // check for the correct position
// check whether any element less than current min value if (data[i] <= val && val <= data[i + 1]) {
if (data[j] < data[min_idx]) { pos = i + 1; // assign correct pos to the index var
min_idx = j; // update index accordingly break; // to get out from the loop
}
} }
// swap min value and element at the ith index
std::swap(data[min_idx], data[i]);
} }
// mark isSorted variable as true // if all elements are smaller than the element
isSorted = true; if (pos == 0) {
pos = top - 1;
}
// shift all element to make a room for new element
for (uint64_t i = top; i > pos; i--) {
data[i] = data[i - 1];
}
top++; // Increment the value of top.
data[pos] =
val; // Assign the value to the correct index in the array
} }
}
/** /**
* @brief Insert the new element in the list * @brief To remove the element from the list
* @param val element that will be inserted * @param val element that will be removed
* @returns void * @returns void
*/ */
void insert(const uint64_t &val) { void remove(const uint64_t &val) {
// overflow check uint64_t pos = search(val); // search the index of the value
if (top == N) { // if search returns -1, element does not present in the list
std::cout << "\nOverflow"; if (pos == -1) {
return; std::cout << "\n Element does not present in the list ";
} return;
// if list is not sorted, insert at the last
// otherwise place it to correct position
if (!isSorted) {
data[top] = val;
top++;
} else {
uint64_t pos = 0; // Initialize the index variable
// Going through each element and find correct position for element
for (uint64_t i = 0; i < top - 1; i++) {
// check for the correct position
if (data[i] <= val && val <= data[i + 1]) {
pos = i + 1; // assign correct pos to the index var
break; // to get out from the loop
}
}
// if all elements are smaller than the element
if (pos == 0) {
pos = top - 1;
}
// shift all element to make a room for new element
for (uint64_t i = top; i > pos; i--) {
data[i] = data[i - 1];
}
top++; // Increment the value of top.
data[pos] = val; // Assign the value to the correct index in the array
}
} }
std::cout << "\n"
<< data[pos] << " deleted"; // print the appropriate message
// shift all the element 1 left to fill vacant space
for (uint64_t i = pos; i < top; i++) {
data[i] = data[i + 1];
}
top--; // decrement the top variable to maintain last index
}
/** /**
* @brief To remove the element from the list * @brief Utility function to print array
* @param val element that will be removed * @returns void
* @returns void */
*/ void show() {
void remove(const uint64_t &val) { // Going through each element in the list
uint64_t pos = search(val); // search the index of the value std::cout << '\n';
// if search returns -1, element does not present in the list for (uint64_t i = 0; i < top; i++) {
if (pos == -1) { std::cout << data[i] << " "; // print the element
std::cout << "\n Element does not present in the list ";
return;
}
std::cout << "\n" << data[pos] << " deleted"; // print the appropriate message
// shift all the element 1 left to fill vacant space
for (uint64_t i = pos; i < top; i++) {
data[i] = data[i + 1];
}
top--; // decrement the top variable to maintain last index
} }
}
/** }; // structure list
* @brief Utility function to print array } // namespace list_array
* @returns void } // namespace data_structures
*/
void show() {
// Going through each element in the list
std::cout << '\n';
for (uint64_t i = 0; i < top; i++) {
std::cout << data[i] << " "; // print the element
}
}
}; // structure list
} // namespace list_array
} // namespace data_structures
/** /**
* @brief Test implementations * @brief Test implementations
@@ -216,19 +228,19 @@ static void test() {
L.insert(20); L.insert(20);
L.insert(18); L.insert(18);
assert(L.top == 7); assert(L.top == 7);
L.show(); // To print the array L.show(); // To print the array
// Remove testing // Remove testing
L.remove(12); // Remove Duplicate value in the list L.remove(12); // Remove Duplicate value in the list
L.remove(15); // Remove the existing value in the list L.remove(15); // Remove the existing value in the list
assert(L.top == 5); assert(L.top == 5);
L.remove(50); // Try to remove the non-existing value in the list L.remove(50); // Try to remove the non-existing value in the list
assert(L.top == 5); assert(L.top == 5);
// LinearSearch testing // LinearSearch testing
assert(L.search(11) == 0); // search for the existing element assert(L.search(11) == 0); // search for the existing element
assert(L.search(12) == 2); assert(L.search(12) == 2);
assert(L.search(50) == -1); // search for the non-existing element assert(L.search(50) == -1); // search for the non-existing element
// Sort testing // Sort testing
L.sort(); L.sort();
@@ -236,9 +248,9 @@ static void test() {
L.show(); L.show();
// BinarySearch testing // BinarySearch testing
assert(L.search(11) == 1); // search for the existing element assert(L.search(11) == 1); // search for the existing element
assert(L.search(12) == 2); assert(L.search(12) == 2);
assert(L.search(50) == -1); // search for the non-existing element assert(L.search(50) == -1); // search for the non-existing element
} }
/** /**
@@ -246,6 +258,6 @@ static void test() {
* @returns 0 on exit * @returns 0 on exit
*/ */
int main() { int main() {
test(); // Execute the tests test(); // Execute the tests
return 0; return 0;
} }