如何在C++中查找数组中数字的最后一个索引

给定N个整数的数组arr []和数字K ，任务是找到arr []中K的最后一次出现。如果不存在该元素，则返回-1 。
例子：

Input: arr[] = {1, 3, 4, 2, 1, 8}, K = 1 
Output: 4 
Explanation: 
There are two occurence of 1 at index 0 and 4. But the last occurence is at index 4.
Input: arr[] = {3, 4, 5, 6, 7}, K = 2 
Output: -1 
Explanation: 
Since 2 is not present in the array. 

方法1：使用递归

• 从给定数组的最后一个索引递归迭代：
  • 基本情况：如果我们递归到达起始索引，则意味着给定元素K不存在于数组中。

if(idx < 0) {
  return -1;
}

• 返回语句：如果递归调用中的当前元素等于K ，则从该函数返回当前索引。

if(arr[idx]==K) {
   return idx;
}

• 递归调用：如果当前索引处的元素不等于K ，则递归调用下一个迭代。

return recursive_function(arr, idx - 1)

下面是上述方法的实现：

CPP

// C++ program for the above approach
#include 
using namespace std;
 
// Recursive function to find the last
// index of the given number K
int findIndex(int arr[], int idx, int K)
{
 
    // Base Case
    if (idx < 0)
        return -1;
 
    // Return Statement
    if (arr[idx] == K) {
        return idx;
    }
 
    // Recursive Call
    return findIndex(arr, idx - 1, K);
}
 
// Driver Code
int main()
{
 
    int arr[] = { 3, 1, 4, 4, 2, 3, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 4;
 
    // Function call
    cout << findIndex(arr, N - 1, K);
 
    return 0;
}

输出：

3

时间复杂度： O(N)，其中N是数组的长度。
方法2：使用inbuit函数find()和find_if()：
这个想法是从数组末尾查找第一个元素，从数组开头查找最后一个元素。步骤如下：

1. 反转给定的数组。
2. 使用find()函数在反向数组中找到值K的第一个元素。
3. 如果由find函数返回的迭代器指向数组的末尾，则该元素不存在于数组中。
4. 否则，使用distance()函数在该反向数组中找到K的位置(例如pos )。
5. 获得给定数组print中的最后一个索引K的距离(N – pos – 1) 。

下面是上述方法的实现：
使用find()

C++

// C++ program for the above approach
#include 
using namespace std;
   
// Function to find the last index of
// the given number K
int findIndex(int arr[], int N, int K)
{
   
    // Reverse the given array arr[]
    reverse(arr, arr + N);
   
    // Find the first occurence of K
    // in this reversed array
    auto it = find(arr, arr + N, K);
   
    // If the element is not present
    // then return "-1"
    if (it == arr + N) {
        return -1;
    }
   
    // Else return the index found
    return (N - distance(arr, it) - 1);
}
   
// Driver Code
int main()
{
   
    int arr[] = { 3, 1, 4, 4, 2, 3, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 4;
   
    // Function call
    cout << findIndex(arr, N, K);
   
    return 0;
}

使用find_if()

C++

// C++ program for the above approach
#include 
using namespace std;
   
// Comparator structure for finding
// index of element with value K
struct comparator {
   
    int elem;
    comparator(int const& i)
        : elem(i)
    {
    }
   
    bool operator()(int const& i)
    {
        return (i == elem);
    }
};
   
// Function to find the last index of
// the given number K
int findIndex(int arr[], int N, int K)
{
   
    // Reverse the given array arr[]
    reverse(arr, arr + N);
   
    // Find the first occurence of K
    // in this reversed array
    auto it = find_if(arr, arr + N,
                      comparator(K));
   
    // If the element is not present
    // then return "-1"
    if (it == arr + N) {
        return -1;
    }
   
    // Else return the index found
    return (N - distance(arr, it) - 1);
}
   
// Driver Code
int main()
{
   
    int arr[] = { 3, 1, 4, 4, 2, 3, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 4;
   
    // Function call
    cout << findIndex(arr, N, K);
   
    return 0;
}

输出：

3

时间复杂度： O(N) ，其中N是给定数组中元素的数量。

方法3 ：(迭代方式)

使用循环查找最后一个位置。

下面是上述方法的实现

C++

// CPP program for the above approach
#include 
using namespace std;
int findIndex(int arr[], int idx, int K)
{
     
    // Traversing the array from
    // last position
    for (int i = idx; i >= 0; i--) {
        if (arr[i] == K)
            return i;
    }
    return -1;
}
 
// Driver Code
int main()
{
 
    int arr[] = { 3, 1, 4, 4, 2, 3, 1 };
    int N = sizeof(arr) / sizeof(arr[0]);
    int K = 4;
 
    // Function call
    cout << findIndex(arr, N - 1, K);
    return 0;
}

输出：

3