std::adjacent_find en C++

Busca en el rango [primero, último] la primera aparición de dos elementos consecutivos que coincidan y devuelve un iterador al primero de estos dos elementos, o al último si no se encuentra ese par. Los elementos se comparan usando el predicado binario p dado o usando ==. 
Hay dos implementaciones posibles de la función como se indica a continuación: 

1. Sin predicado binario: 

ForwardIt adjacent_find( ForwardIt first, ForwardIt last );
first, last : the range of elements to examine

Ejemplo: 
Dada una array ordenada de n elementos que contiene todos los elementos únicos menos uno, la tarea es encontrar el elemento repetido en la array. 

Ejemplos: 

Input :  arr[] = { 1, 2, 3, 4, 4}
Output :  4

Input :  arr[] = { 1, 1, 2, 3, 4}
Output :  1

Hemos discutido este problema con otros enfoques aquí .

// C++ Program to find the only
// repeating element in sorted array
// using std :: adjacent_find
// without predicate
#include <iostream>
#include <algorithm>
 
int main()
{
    // Sorted Array with a repeated element
    int A[] = { 10, 13, 16, 16, 18 };
 
    // Size of the array
    int n = sizeof(A) / sizeof(A[0]);
 
    // Iterator pointer which points to the address of the repeated element
    int* it = std::adjacent_find(A, A + n);
 
    // Printing the result
    std::cout << *it;
}

Producción: 

16

2. Con predicado binario: 

ForwardIt adjacent_find( ForwardIt first, ForwardIt last, BinaryPredicate p );
first, last : the range of elements to examine
p :  binary predicate which returns true 
if the elements should be treated as equal. 

Return value :
An iterator to the first of the first pair of identical elements, '
that is, the first iterator it such that *it == *(it+1) for the first 
version or p(*it, *(it + 1)) != false for the second version.
If no such elements are found, last is returned.

Ejemplo: 
dado un contenedor de tamaño n y un rango entre [0 … n], escriba un programa para verificar si está ordenado en orden ascendente o no. Se permiten valores iguales en la array y dos valores iguales consecutivos se consideran ordenados. 

Input : 2 5 9 4      // Range = 3
Output : Sorted in given range.

Input : 3 5 1 9     // Range = 3
Output : Not sorted in given range.

// CPP program to illustrate
// std :: adjacent_find'
// with binary predicate
#include <algorithm>
#include <iostream>
#include <vector>
 
int main()
{
    std::vector<int> vec{ 0, 1, 2, 5, 40, 40, 41, 41, 5 };
 
    // Index 0 to 4
    int range1 = 5;
 
    // Index 0 to 8
    int range2 = 9;
 
    std::vector<int>::iterator it;
 
    // Iterating from 0 to range1,
    // till we get a decreasing element
    it = std::adjacent_find(vec.begin(),
                            vec.begin() + range1, std::greater<int>());
 
    if (it == vec.begin() + range1)
    {
        std::cout << "Sorted in the range : " << range1 << std::endl;
    }
 
    else
    {
        std::cout << "Not sorted in the range : " << range1 << std::endl;
    }
 
    // Iterating from 0 to range2,
    // till we get a decreasing element
    it = std::adjacent_find(vec.begin(),
                            vec.begin() + range2, std::greater<int>());
 
    if (it == vec.begin() + range2)
    {
        std::cout << "Sorted in the range : " << range2 << std::endl;
    }
 
    else
    {
        std::cout << "Not sorted in the range : " << range2 << std::endl;
    }
}

Producción: 

Sorted in the range : 5
Not sorted in the range : 9

Este artículo es una contribución de Rohit Thapliyal . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.