Question

我需要使用递归找到数组中字符串最少的下标，如果数组没有要检查的元素，则返回-1。这是我到目前为止所提出的，但它不起作用。

int leastElement(string a[], int n)
{
    if(n == 1)
        return 0;



    if(a[0] > a[n])
        a[0] = a[n];

    return leastElement(a, n-1);
}

Answer 1

int leastElement(string a[], int n)
{
    if (n <= 0) {
        return -1;
    }
    if (n == 1) {
        return 0;
    }
    int k = 1 + leastElement(a + 1, n - 1);
    if (a[0] < a[k]) {
        return 0;
    } else {
        return k;
    }
}

Answer 2

递归的一个关键概念是下一次递归带有前一个递归的状态。例如，链表是递归的理想对象，因为下一个递归通常基于先前的链表链接。

在这种情况下，数组需要一个起点和终点来定义一个数组。因此，您需要携带数组的开始和结束索引。

int leastElement(int arr[], int start, int end) {
  if (start >= end -1) {
    return start;
  }
  else {
    int subLeastElement = leastElement (arr, start + 1, end);
    if (arr[start] <= arr[subLeastElement]) {
      return start;
    }
    else {
      return subLeastElement;
    }
  }
}

//This provides a simplified start point
int leastElement(int arr[], int n) {
    return leastElement(arr, 0, n);
}

这里的工作示例：

coliru code

Answer 3

#include<iostream>
    using namespace std;
    char minimum(char a, char b)
    {
        if(a < b)
            return a;
        else
            return b;

    }
    char leastElement(string a, int n)
    {
        if(n == -1)
            return -1;
        if(n == 0)
            return a[0];
        return minimum(a[n],leastElement(a, n-1));
    }
    int main()
    {
        string a= "AaHelloz";
        //cout<<a;
        cout<<leastElement(a,a.length()-1);

        return 0;
    }

这是通过递归获取字符串中最小字符的简单代码。

Answer 4

您的递归深度将与n成比例，您可以在每个级别将数组分成两半：

int leastElement(string a[], int n) {
       if (n <= 0)
          return -1;  // paranoid about empty array
       if (n == 1)
          return 0;
       const int left = leastElement(a, n/2);
       const int right = leastElement(a + n/2, n - n/2);
       if (left == -1) // paranoia again
          return right + n/2;
       if (right == -1)
          return left;
       return (a[left] < a[right + n/2]) ? left : right + n/2;
}

int main() {
  string a[] = {
    "ugl", "nvk", "akl", "ngl", "qal", "fgp", 
    "rjv", "kln", "ahf", "lak", "vjh",
    "sdf", "lak", "lmc", "lhf", "wer"
  };
  const int i = leastElement(a, 16);
  cout << i; // returns 8 "ahf"
  return 0;
}

Answer 5

这个想法是以递归方式访问列表中的每个字符串，然后在递归展开时，用当前最小值检查每个字符串。

int leastElement(std::string a[], int n) {
    if(n == 0)
        return -1;

    int least = leastElement(a, n - 1);
    if (least > -1 && a[least] < a[n - 1]) {
        return least;
    }
    return n - 1;
}

Answer 6

这是一个演示程序，显示如何编写函数

#include <iostream>
#include <string>

int leastElement( const std::string a[], int n )
{
    if ( n <= 0 ) return - 1;

    int i = 1 + leastElement( a + 1, n - 1 );

    return i == 0 || !( a[i] < a[0] ) ? 0 : i;
}


int main()
{
    std::string a[] = { "C", "D", "A", "E" };

    int i = leastElement( a, sizeof( a ) / sizeof( *a ) );
    std::cout << i << ": " << a[i] << std::endl;

    return 0;
}

程序输出

2: A

注意这种情况

!( a[i] < a[0] )

如果有几个相等的最小元素且这个条件提供了这个要求，通常这些函数必须返回第一个最小元素。

要减小递归的深度，可以将数组拆分为两部分。这是一个示范程序

#include <iostream>
#include <string>

int leastElement( const std::string a[], int n )
{
    if ( n <= 0 ) return -1;
    if ( n == 1 ) return 0;

    int i = leastElement( a, n / 2 );
    int j = n / 2 + leastElement( a + n / 2, n - n / 2 );

    return !( a[j] < a[i] ) ? i : j;
}

int main()
{
    std::string a[] = { "C", "D", "A", "E" };

    int i = leastElement( a, sizeof( a ) / sizeof( *a ) );
    std::cout << i << ": " << a[i] << std::endl;
    return 0;
}

输出与上面相同

2: A

c ++ recursion查找字符串数组中的最小元素

6 个答案: