Sorry, es en C, pero creo que podrás seguirlo, es sencillo. Se basa en que con numeradores impares éstos se repiten 3 veces seguidas, con impares solo 2. De igual forma todos los numeradores impares hacen la fracción positiva, los pares la hacen negativa. La serie dura mientras el denominador sea positivo:

#include <stdio.h>
 
int main() {
    int n;
    int i;
    int k;
    int numerador;
    int denominador;
    int repeticiones;
 
    printf("> ");
    scanf("%d", &n);
    printf("S =");
 
    numerador = 1;
    denominador = 1;
    i = 0;
    k = 0;
    while(denominador>0) {
        // Calculo las veces que se repite el numerador
        repeticiones = 2 + numerador%2;
 
        printf(" %d/%d ", numerador, denominador);
 
        // Calculo el próximo denominador
        if(k<n-1)
            denominador += 2;
        else if(k>n-1)
            denominador -= 2;
        ++k;
 
        // Control del bucle de las repeticiones
        if(++i==repeticiones) {
            ++numerador;
            i=0;
        }
 
        // Escribo el signo
        if(denominador>0) {
            if(numerador%2)
                putchar('+');
            else
                putchar('-');
        }
    }
}

Buf, creo que te has metido en algo serio. Si no sabes cómo hacer aparecer >>> para cada vez que un usuario deba entrar datos, todo el apartado de la calculadora se te hace muy grande.
Cómo muestra de algo parecido:
https://github.com/btmills/calculator

Puedes ver que no es tan sencillo.

Cómo te había explicado una operación booleana en C se evalúa a 1 si el resultado es true y 0 si el resultado es false. El código aprovecha este hecho en el trozo de código *cad==c, es decir, si el carácter actual de la cadena es igual a carácter c devolverá 1, caso contrario 0.
Este resultado se suma a lo que devuelva la siguiente llamada a buscar_c apuntando al siguiente carácter de la cadena. Y todo esto es lo que retornará la función.
Por recursividad los resultados se irán acumulando y cuando hayan retornado todas las funciones la última entregará el resultado esperado.

-------------------- Fuera del tema ---------------------------
Por otra parte es importante recalcar el cad+1 en vez de ++cad en el argumento de buscar_c. Esto es debido a que además de incrementar cad en 1 en otra parte se hace uso del valor de esa variable. Uno no sabe qué operando evaluará antes C en una operación matemática. Si hubiera sido ++cad, al evaluar *cad==c lo haría con el siguiente carácter al que nos interesa y el programa fallaría y por eso he optado por no modificar dicha variable. Pero todo esto tiene que ver con los puntos de secuencia, algo de lo que tendrás oportunidad de aprender más adelante.

Para hacerla recursiva sería:

int buscar_c(char *cad, char c) {
    if(*cad=='\0')
        return 0;
    return (*cad==c)+buscar_c(cad+1,c);
 }

El else tuyo no tiene sentido.
Éste código funciona para las implementaciones que consideren 1 como resultado de un true, que son todas las que conozco.

Buena respuesta. Me quito el sombrero.

Esto con un manual o tutorial básico de C++ lo aprenderás en dos horas. Suele estar en las primeras páginas y con ejercicios.

Para que te funcione de forma recursiva se debe guardar el estado de unas cuantas cosas, podrías pasarlas por los argumentos pero eso implicaría complicar la firma de tu función de forma innecesaria, ya que C dispone de herramientas para eso: las variables estáticas.

Esta podría ser una solución elegante

#include <stdio.h>
 
void rombo(unsigned altura) {
    static unsigned h; // Height, altura
    static unsigned w; // Width, ancho
    static unsigned i; // Iteration, el escalon actual
 
    if(altura) {
        if(altura%2 == 0) // Para que quede bien cuadrado
            ++altura;     // altura debe ser impar
        h = altura;
        w = 1;
        i = 0;
    }
 
    if(i<h) { // Mientras el reglón no ha llegado a la altura del rombo
        int j;
        for(j=0; j<=h/2-w/2; ++j) // Calculo los espacios por escalon
            putchar(' ');         //    y los imprimo
        for(j=0; j<w; ++j) // Imprimo
            putchar('*');  //    los asteriscos
        putchar('\n'); // Al siguiente reglón
        if(i<h/2) w += 2; // Calculo los asteriscos que
        else w -= 2;      //    habrá en el siguiente reglon
        ++i; // Voy al siguiente reglón
        rombo(0); // Llamo de nuevo a rombo indicando que siga con los datos que hay (0)
    }
}
 
int main() {
    rombo(6);
}

Seguramente usar el depurador y situar breakpoints cerca de dónde posiblemente esté el fallo. Pero yo no uso. En mi caso hago que la aplicación escriba en stderr, que no pasa por ningún buffer y escribe directamente en la pantalla. Voy situándolos cerca de dónde creo que podría estar el fallo. Y si con eso no lo resuelvo empiezo desde el main para ir recorriendo las llamadas a funciones y llegar hasta el fallo. ¡

La verdad, me da pereza aprender a usar el depurador, ya lo hago yo con stderr, jajaja.

Si lo haces con arrays de punteros
deberás usar *alloc para conseguir dimensionar memoria antes de guardar una cadena en ella. Y cuando acabes con esas cadenas destruirlas con free. A lo mejor se te rompe por eso.

En cambio si todo son arrays ya tienes la memoria dimensionada, pero a diferencia de los punteros dimensionados con *alloc su ámbito empieza en la función que los declaró, ten presente eso.

Sea como sea a la hora de entregar palabras recuerda que tanto punteros como arrays se comportan como punteros y una función que espere un char* muy amablemente va a acoger un array:
Tanto si has hecho
cómo
puedes pasar a la función que espera un char*

Mira, es muy fácil:

El dato tiene una estructura clásica de árbol binario

Y a partir de aquí se lee la función
No estaba puesto, pero considero unsgined a contador pues lo normal es que la raíz sea 0 y vaya ascendiendo a cada nivel, por tanto los números negativos no son aptos para este menester.
mostrarArbol recibe el puntero a un tipo Nodo para no andar todos los datos de cada estructura, contador indicará la profundidad del nivel a que se encuentra (esto lo saco de más adelante como veremos).

Este es la condición de fin de recursividad. Ésta se detendrá al llegar a un nodo vacío, es decir, cuándo se esté fuera del árbol.

Pero si la nodo forma parte del árbol se seguirá por su rama derecha. No hay que preocuparse por si está vacía, ya que hemos visto anteriormente que la función se encarga de terminar la búsqueda si eso pasa. Además se le indica a la función que el siguiente nivel será uno mas que éste, con contador+1. No se ha usado contador++ porque se quiere retener, para la actual instancia de la función, del valor que guarda.

Y por esto es por lo que se necesita el dato de contador: a cada nivel se le representa su profundidad con un espacio. Al final de los espacios se coloca el dato que hay en el nodo. Así la representación es más visual.
Se procede a realizar con la rama izquierda lo que se hacía con la derecha.