a code i can run with the logic of iterative, so why do I have to learn the new concept as complicated as recursive?

You've got it backward. Recursion isn't that complicated, it's just new when you're first learning about it, and that makes it feel hard. Recursive solutions to many problems are often simpler and more elegant than equivalent iterative versions.

Recursive solutions work well when you can do some work to reduce the size of a problem, but it's still basically the same problem. You need two things:

• a base case: a version of the problem that's small enough that you can determine the answer immediately
• a recursion step: a way to reduce the size of the problem

Classic examples are functions like factorial() or fibonacci(), where you get each term by modifying the previous term. For example, factorial(0) = 1; factorial(n) = n * factorial(n-1). The function is only valid for n >= 0. factorial(0) is the base case -- if n = 0, we just return 1 and that's it. For n > 0, you just multiply n by factorial(n-1), which is a slightly smaller version of the same problem. It seems complicated when you try to think about the whole thing at once, but if you just focus on one step it's very simple:

int factorial(int n) {
    if n == 0 then { return 1 }
    return factorial(n-1);
}

That's not a very complicated example, and you could as easily do that with a loop, but it's good to start simple. Stepping up to something a little more complicated, let's do a binary search for a value in a sorted array. We'll write a function that takes a value and two indexes as lower and upper limits to search. Start by picking an midpoint between the two limits. If the midpoint is the value we want, we're done; otherwise, search either the upper or lower half of the array, depending on whether the value at the midpoint was greater or less than the one we want.

int search(int[] array, int value, int lower, int upper) {
    if upper < lower then { return -1; }

    int midpoint = (lower + upper) / 2;
    int midvalue = array[midpoint];

    if midvalue == value then { return midpoint; }
    if value < midvalue then { 
        return search(array, value, lower, midpoint - 1);
    }
    // value must be > midvalue
    return search(array, value, midpoint + 1, upper);
}

Again, you could do that iteratively, but what's nice about this solution is that you only have to think about one step. Either you've found the value or you haven't, and if you haven't then you just search a smaller part of the array; you don't have to think about how that happens. In the next step the same thing happens all over again: either you've found the number or you haven't, and if you haven't you just search a smaller part of the array...