Foros aprenderaprogramar.com
Didáctica y divulgación de la programación

Buenos dias.

Ya he conseguido que funcione.
El problema estaba en los ciclos for en los que declaraba "i = lim_elemento - 1"
ó "i = lim_elemento + 1". Tenía que hacerse unicamente como lim_elemento sin añadir nada.
Pongo a continuación el código. Puede que no sea el más eficiente pero da resultado
// Ejercicio 7.24: Ordenamiento Quicksort //

#include <stdio.h>

void quicksort ( int arreglo[], int tamanio, int inicio, int fin);
void intercambio (int *ptr1, int *ptr2);
int particion (int arreglo[], int tamanio, int izq, int dcha);

main()
{
    int i;
    int arreglo [10] = {37,2,6,4,89,8,10,12,68,45};

    printf("Arreglo desordenado\n\n");
    for(i = 0; i < 10; i++)
    {
        printf("%d ", arreglo[i]);
    }

    quicksort(arreglo, 10, 0, 9);

    printf("\n\nArreglo ordenado\n\n");

    for(i = 0; i < 10; i++)
    {
        printf("%d ", arreglo[i]);
    }


    return 0;
}

void quicksort( int arreglo[], int tamanio, int inicio, int fin)
{
    int posicion;

    if (inicio >= fin )
    {
        return;
    }

    else
    {
        posicion = particion(arreglo, tamanio, inicio, fin);
        //recursividad//
        quicksort(arreglo, tamanio, posicion + 1, fin);
        quicksort(arreglo, tamanio, inicio, posicion -1);
    }
}

int particion (int arreglo[], int tamanio, int inicio, int fin)
{
    int i, elemento = inicio, lim_elemento;

    for (i = fin; arreglo[i] > arreglo[elemento] && arreglo[i] != arreglo[elemento]; i--)
        {
            ;
        }
    intercambio(&arreglo[elemento], &arreglo[i]);
    elemento = i;

    for (i = inicio; arreglo[i] < arreglo[elemento] && arreglo[i] != arreglo[elemento]; i++)
    {
        ;
    }
    intercambio(&arreglo[elemento], &arreglo[i]);
    lim_elemento = elemento;
    elemento = i;

    for (i = lim_elemento; arreglo[i] > arreglo[elemento] && arreglo[i] != arreglo[elemento]; i--)
    {
        ;
    }
    intercambio(&arreglo[elemento], &arreglo[i]);
    lim_elemento = elemento;
    elemento = i;

    for (i = lim_elemento; arreglo[i] < arreglo[elemento] && arreglo[i] != arreglo[elemento]; i++)
    {
        ;
    }
    intercambio(&arreglo[elemento], &arreglo[i]);

    return i;
}

void intercambio (int *ptr1, int *ptr2)
{
    int temp;
    temp = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = temp;
}


Buenas tardes.

El mecanismo lo entiendo bien, el problema creo que está en la recursividad, que es lo que me da error, porque el colocar el primer elemento en su posición definitiva sí que me sale, lo malo es al intentar ordenar los 2 vectores restantes (izquierda y derecha del número colocado) aplicando la recursividad
Un saludo

Buenas noches.
He escrito el siguiente código pero me da error al final, la función quicksort funciona bien si elimino las 2 últimas líneas pero entonces no termina de ordenar el arreglo.
¿Podría alguien decirme donde está el error?
Muchas gracias
// Ejercicio 7.24: Ordenamiento Quicksort //

#include <stdio.h>

void quicksort ( int arreglo[], int tamanio, int inicio, int fin);
void intercambio (int *ptr1, int *ptr2);
void particion (int arreglo[], int tamanio, int izq, int dcha);

main()
{
    int i;
    int arreglo [10] = {37,2,6,4,89,8,10,12,68,45};

    printf("Arreglo desordenado\n\n");
    for(i = 0; i < 10; i++)
    {
        printf("%d ", arreglo[i]);
    }

    quicksort(arreglo, 10, 0, 9);

    printf("\n\nArreglo ordenado\n\n");

    for(i = 0; i < 10; i++)
    {
        printf("%d ", arreglo[i]);
    }


    return 0;
}

void quicksort( int arreglo[], int tamanio, int inicio, int fin)
{
    int i, elemento, lim_elemento;

    if (inicio >= fin )
    {
        return;
    }

    else
    {
        for (i = fin; arreglo[i] > arreglo[inicio]; i--)
        {
            ;
        }

        intercambio(&arreglo[inicio], &arreglo[i]);
        elemento = i;

        for (i = inicio; arreglo[i] < arreglo[elemento]; i++)
        {
            ;
        }

        intercambio(&arreglo[elemento], &arreglo[i]);
        lim_elemento = elemento;
        elemento = i;

        for (i = lim_elemento-1; arreglo[i] > arreglo[elemento]; i--)
        {
            ;
        }

        intercambio(&arreglo[elemento], &arreglo[i]);
        lim_elemento = elemento;
        elemento = i;

        for (i = lim_elemento+1; arreglo[i] < arreglo[elemento]; i++)
        {
            ;
        }

        intercambio(&arreglo[elemento], &arreglo[i]);
        lim_elemento = elemento;
        elemento = i;

        printf("\n%d\n\n", i);

        particion(arreglo, 10, 0, elemento -1);
        particion(arreglo, 10, elemento + 1, 9);

    }
}

void particion (int arreglo[], int tamanio, int izq, int dcha)
{
    quicksort(arreglo, 10, izq, dcha);
}

void intercambio (int *ptr1, int *ptr2)
{
    int temp;
    temp = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = temp;
}

La otra variante de código que he escrito es las siguiente, pero me ocurre lo mismo.

// Ejercicio 7.24: Ordenamiento Quicksort //

#include <stdio.h>

void quicksort ( int arreglo[], int tamanio, int inicio, int fin);
void intercambio (int *ptr1, int *ptr2);
int particion (int arreglo[], int tamanio, int izq, int dcha);

main()
{
    int i;
    int arreglo [10] = {37,2,6,4,89,8,10,12,68,45};

    printf("Arreglo desordenado\n\n");
    for(i = 0; i < 10; i++)
    {
        printf("%d ", arreglo[i]);
    }

    quicksort(arreglo, 10, 0, 9);

    printf("\n\nArreglo ordenado\n\n");

    for(i = 0; i < 10; i++)
    {
        printf("%d ", arreglo[i]);
    }


    return 0;
}

void quicksort( int arreglo[], int tamanio, int inicio, int fin)
{
    int posicion;

    if (inicio >= fin )
    {
        return;
    }

    else
    {
        posicion = particion(arreglo, tamanio, inicio, fin);

        quicksort(arreglo, 10, inicio, posicion -1);
        quicksort(arreglo, 10, posicion + 1, fin);

    }
}

int particion (int arreglo[], int tamanio, int inicio, int fin)
{
    int i, elemento, lim_elemento;

    for (i = fin; arreglo[i] > arreglo[inicio] ; i--)
        {
            ;
        }

        intercambio(&arreglo[inicio], &arreglo[i]);
        elemento = i;

        for (i = inicio; arreglo[i] < arreglo[elemento] ; i++)
        {
            ;
        }

        intercambio(&arreglo[elemento], &arreglo[i]);
        lim_elemento = elemento;
        elemento = i;

        for (i = lim_elemento-1; arreglo[i] > arreglo[elemento]; i--)
        {
            ;
        }

        intercambio(&arreglo[elemento], &arreglo[i]);
        lim_elemento = elemento;
        elemento = i;

        for (i = lim_elemento+1; arreglo[i] < arreglo[elemento]; i++)
        {
            ;
        }

        intercambio(&arreglo[elemento], &arreglo[i]);
        lim_elemento = elemento;
        elemento = i;

        return elemento;


}

void intercambio (int *ptr1, int *ptr2)
{
    int temp;
    temp = *ptr1;
    *ptr1 = *ptr2;
    *ptr2 = temp;
}


Buenas noches.
Pongo otra respuesta ya que no me deja editar las anteriores. Lo siento si ocupa mucho espacio el post.

Ya he encontrado el fallo de la línea 387 que comentaba en la respuesta anterior. Resulta que soy tonto y para salir del ciclo 'switch' usaba 'return' en vez de 'break'    .
Tuve que modificar también un par de cosillas en las respuestas que daba al determinar un ganador pero cosas sin importancia.
Antes de que digais nada, cuando determina ganador entre 2 jugadores con carta más alta no lo determina bien, pero porque me falta añadir el aspecto de elegir cual es la mayor carta de la mano (detalle sin importancia).

Lo que aún no entiendo es el otro fallo que comente en la respuesta anterior:
-Program received signal SIGSEGV, Segmentation fault. en la línea 46.
Parece ser que no puede acceder a algún dato..... pero este error no ocurre siempre...

Agradecería cualquier ayuda.
Pongo el código que ya funciona a continuación:

 /*Ejercicio 7.13: Determinar cual es la mejor mano de poker */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* prototipos */
void baraja( int wMazo[][ 13 ] );
void reparte( const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], int carta_inicial, int carta_final );

void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[], const char *combinacion_simple[], const char *combinacion_doble[], int carta_inicial, int carta_final,int resultados[][9] , int jugador );

void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble);

void determina_ganador(int resultados[][9],int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[]);

int main()
{
   /* inicializa el arreglo palo */
   const char *palo[ 4 ] = { "Corazones", "Diamantes", "Treboles", "Espadas" };

   /* inicializa el arreglo cara */
   const char *cara[ 13 ] =
      { "As", "Dos", "Tres", "Cuatro",
        "Cinco", "Seis", "Siete", "Ocho",
        "Nueve", "Diez", "Jota", "Dama", "Rey" };

   const char *combinacion_simple[7] = {"carta mas alta", "pareja", "trio", "poker","escalera", "color", "escalera de color" };

   const char *combinacion_doble[3] = {"carta mas alta", "doble pareja","full"};

   /* inicializa el arreglo mazo */
   int mazo[ 4 ][ 13 ] = { 0 };

   int jugadores, jugador;

   srand( time( NULL ) ); /* semilla del generador de números aleatorios */

   baraja( mazo );

   printf("Por favor introduzca el número de jugadores: ");
   scanf("%d", &jugadores);

   int resultados[2][9] = {-1,-1,-1,-1,-1,-1,-1,-1,-1,
                           -1,-1,-1,-1,-1,-1,-1,-1,-1};// arreglo que guarda los resultados //

   for (jugador = 0; jugador < jugadores; jugador++)
   {
       printf("\n\nJugador %d\n\n", jugador + 1);
       reparte( mazo, cara, palo,1 + (jugador * 5),5 + (jugador * 5) );
       combinacion_mano(mazo,cara,palo,combinacion_simple, combinacion_doble,1 + (jugador * 5),5 + (jugador * 5), resultados, jugador );
   }

   determina_ganador(resultados, jugadores, combinacion_simple, combinacion_doble,cara);


   return 0; /* indica terminación exitosa */

} /* fin de main */

/* baraja las cartas del mazo */
void baraja( int wMazo[][ 13 ] )
{
   int fila;    /* número de fila */
   int columna; /* número de columna */
   int carta;   /* contador */

   /* elige aleatoriamente un espacio para cada una de las 52 cartas */
   for ( carta = 1; carta <= 52; carta++ ) {

      /* elije una nueva ubicación al azar hasta que encuentra un espacio vacío  */
      do {
         fila = rand() % 4;
         columna = rand() % 13;
      } while( wMazo[ fila ][ columna ] != 0 ); /* fin de do...while */

      /* coloca el número de carta en el espacio vacío del mazo */
      wMazo[ fila ][ columna ] = carta;
   } /* fin de for */

} /* fin de la función baraja */

/* reparte las cartas del mazo */
void reparte( const int wMazo[][ 13 ], const char *wCara[],
           const char *wPalo[],int carta_inicial, int carta_final )
{
   int carta;   /* contador de cartas */
   int fila;    /* contador de filas */
   int columna; /* contador de columnas */

   /* reparte cada una de las 52 cartas */
   for ( carta = carta_inicial; carta <= carta_final; carta++ ) {

      /* realiza el ciclo a través de las filas de wMazo */
      for ( fila = 0; fila <= 3; fila++ ) {

         /* realiza el ciclo a través de las columnas de wMazo en la fila actual */
         for ( columna = 0; columna <= 12; columna++ ) {

            /* si el espacio contiene la carta actual, despliega la carta */
            if ( wMazo[ fila ][ columna ] == carta ) {
               printf( "%6s de %-9s%c", wCara[ columna ], wPalo[ fila ],
                  carta % 2 == 0 ? '\n' : '\t' );
            } /* fin de if */

         } /* fin de for */

      } /* fin de for */

   } /* fin de for */

} /* fin de la función reparte */


//Determina la combinacion de la mano //
void combinacion_mano(const int wMazo[][ 13 ], const char *wCara[], const char *wPalo[],
                      const char *combinacion_simple[], const char *combinacion_doble[],int carta_inicial, int carta_final,int resultados[][9],int jugador )
{
   int carta;   /* contador de cartas */
   int fila;    /* contador de filas */
   int columna; /* contador de columnas */
   int posicion_carta;// contador para el resto de cartas que se comparan en función de la actual //
   int numero_cartabase; //numero de la carta actual //
   int palo_cartabase; //palo de la carta actual //
   int num_combinacion_simple = 0; //combinacion que hay en la mano //
   int num_combinacion_doble = 0; // segunda combinación que hay en la mano //
   int mano[5] = {0};
   int color = 1; // contador para saber si tienes color en la mano //
   int escalera = 1; // contador para saber si tienes escalera //
   int numero_carta_simple;
   int numero_carta_doble;
   int carta_mas_alta = 0;


   /* reparte cada una de las 52 cartas */
   for ( carta = carta_inicial; carta <= carta_final; carta++ ) {

      /* realiza el ciclo a través de las filas de wMazo */
      for ( fila = 0; fila <= 3; fila++ ) {

         /* realiza el ciclo a través de las columnas de wMazo en la fila actual */
         for ( columna = 0; columna <= 12; columna++ ) {

            /* Determina si hay  una combinacion en función de la carta actual */
            if ( wMazo[ fila ][ columna ] == carta && mano[carta - carta_inicial ] == 0 )
            {
              numero_cartabase = columna;
              palo_cartabase = fila;

              if(carta == carta_inicial ) // determina si tienes color a partir de la primera carta //
              {
                 for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {

                  /* realiza el ciclo a través de las filas de wMazo */
                  for ( fila = 0; fila <= 3; fila++ ) {

                     /* realiza el ciclo a través de las columnas de wMazo en la fila actual */
                     for ( columna = 0; columna <= 12; columna++ ) {
                            if( wMazo[fila][columna] == posicion_carta && fila == palo_cartabase)
                            {
                                if (fila == palo_cartabase)
                                {
                                    color++;
                                    numero_carta_simple = numero_cartabase;
                                }

                               if(columna == numero_cartabase + carta)
                               {
                                   escalera++;
                                   numero_carta_simple = numero_cartabase;
                               }

                            }

                     }
                  }
                }

              } // fin carta == 1 //

              if (color != 5)// si no hay color //
              {
                 if(num_combinacion_simple == 0)
              {
                 for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {

                  /* realiza el ciclo a través de las filas de wMazo */
                  for ( fila = 0; fila <= 3; fila++ ) {

                     /* realiza el ciclo a través de las columnas de wMazo en la fila actual */
                     for ( columna = 0; columna <= 12; columna++ ) {
                            if(carta_mas_alta < numero_cartabase)
                            {
                                carta_mas_alta = numero_cartabase;
                            }
                            if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
                            {
                               num_combinacion_simple++;
                               numero_carta_simple = numero_cartabase;
                               mano[posicion_carta - 1] = 1;
                            }

                     }
                  }
                }

              }// fin if combinacion simple //

              else // la combinacion es doble//
              {
                 for ( posicion_carta = carta + 1; posicion_carta <= carta_final; posicion_carta++ ) {

                      /* realiza el ciclo a través de las filas de wMazo */
                      for ( fila = 0; fila <= 3; fila++ ) {

                         /* realiza el ciclo a través de las columnas de wMazo en la fila actual */
                         for ( columna = 0; columna <= 12; columna++ ) {
                                if( wMazo[fila][columna] == posicion_carta && columna == numero_cartabase)
                                {
                                   num_combinacion_doble++;
                                   numero_carta_doble = numero_cartabase;
                                   mano[posicion_carta - 1] = 1;
                                }

                         }
                      }
                    }

                } // fin de else //

              }// fin de if si no hay color //



            } /* fin de if */

         } /* fin de for */

      } /* fin de for */

   } /* fin de for */

   if(escalera == 5) // establece la escalera //
   {
       num_combinacion_simple = 4;
   }

   if(color == 5) // Establece el color //
   {
       num_combinacion_simple = 5;
   }

   if(escalera == 5 && color == 5) // Establece la escalera de color //
   {
       num_combinacion_simple = 6;
   }
   if(num_combinacion_simple == 2 && num_combinacion_doble == 1) // establece la otra posibilidad de full//
   {
       num_combinacion_doble = 2;
   }

   if (num_combinacion_doble == 0)
   {
        printf("\n\nEn esta mano hay %s \n", combinacion_simple[num_combinacion_simple] );
   }

   else
   {
       printf("\n\nEn esta mano hay %s \n", combinacion_doble[num_combinacion_doble] );
   }

   if(num_combinacion_simple == 0)
   {
       numero_carta_simple = carta_mas_alta;
   }

   almacena_resultados(resultados, num_combinacion_simple, num_combinacion_doble, jugador, numero_carta_simple, numero_carta_doble);

} // fin de la funcion combinacion mano //


// funcion almacena resultados //
void almacena_resultados( int resultados[][9], int num_combinacion_simple, int num_combinacion_doble,int jugador,int numero_carta_simple,int numero_carta_doble)
{
    if ( num_combinacion_doble == 0)
    {
      switch (num_combinacion_simple) {

    case 0: resultados[jugador][0] = numero_carta_simple;
            break;
    case 1: resultados[jugador][1] = numero_carta_simple;
            break;
    case 2: resultados[jugador][3] = numero_carta_simple;
            break;
    case 3: resultados[jugador][7] = numero_carta_simple;
            break;
    case 4: resultados[jugador][4] = numero_carta_simple;
            break;
    case 5: resultados[jugador][5] = numero_carta_simple;
            break;
    case 6: resultados[jugador][8] = numero_carta_simple;
            break;
    } // fin switch //

    }// fin if //

    else
    {
       switch (num_combinacion_doble) {

    case 1: resultados[jugador][2] = numero_carta_doble;
            break;
    case 2: resultados[jugador][6] = numero_carta_doble;
            break;
    }//fin switch//

    }// fin else//
}

// funcion determina_ganador //

void determina_ganador(int resultados[][9], int jugadores,const char *combinacion_simple[], const char *combinacion_doble[],const char *cara[])
{
    int jugador = 0;
    int mejor = -1;
    int jugada = 8;
    int jugador_ganador1;
    int jugador_ganador2 = -1;
    int mano_simple = -1;
    int mano_doble = 0;



       while(resultados[jugador][jugada] == -1 && jugador < jugadores)
       {
           jugador++;
           if (jugador == jugadores)
           {
               jugador = 0;
               jugada--;
           }

       }



           mejor = resultados[jugador][jugada];

           jugador_ganador1 = jugador;
           jugador++;
           for(; jugador < jugadores; jugador++)
           {
               if(resultados[jugador][jugada] > mejor )
               {
                   mejor = resultados[jugador][jugada];
                   jugador_ganador1 = jugador;
               }
               if(resultados[jugador][jugada] == mejor )
               {
                   jugador_ganador2 = jugador;
               }
           }


    switch (jugada) {

    case 0: mano_simple = 0;
            break;
    case 1: mano_simple = 1;
            break;
    case 2: mano_doble = 1;
            break;
    case 3: mano_simple = 2;
            break;
    case 4: mano_simple = 4;
            break;
    case 5: mano_simple = 5;
            break;
    case 6: mano_doble = 2;
            break;
    case 7: mano_simple = 3;
            break;
    case 8: mano_simple = 6;
            break;
    }

    if (jugador_ganador2 == -1) // si no hay empate //
    {
        if(mano_doble == 0) // si es mano simple//
        {
            if(mano_simple != 5) // si no hay color //
            {
               printf("\n\nHa ganado el jugador %d con %s de %s\n\n",jugador_ganador1 + 1, combinacion_simple[mano_simple], cara[mejor]);
            }
            else //hay color//
            {
                printf("\n\nHa ganado el jugador %d con %s \n\n",jugador_ganador1 + 1, cara[mano_simple]);
            }

        }
        else // si es mano doble //
        {
           printf("\n\nHa ganado el jugador %d con %s de %s\n\n",jugador_ganador1 + 1, combinacion_doble[mano_doble], cara[mejor]);
        }

    }

    else // hay empate //
    {
        if(mano_doble == 0) // si es mano simple /7
        {
            if(mano_simple != 5) // si no hay color//
            {
               printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, combinacion_simple[mano_simple], cara[mejor]);
            }
            else //hay color//
            {
                printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, cara[mano_simple]);
            }

        }
        else // si es mano doble //
        {
           printf("\n\nHa habido un empate entre el jugador %d y el jugador %d con %s de %s\n\n",jugador_ganador1 + 1,jugador_ganador2 + 1, combinacion_doble[mano_doble], cara[mejor]);
        }

    }



}


Buenos dias.
He estado comprobando lo que me decías pero a mi no me pasa.
A mi siempre me dice la combinación correcta y con el número de jugadores correcto.
Lo único que no consigo que haga bien es determinar quien gana, que directamente no lo hace, se queda a la mitad de la función.
Seguiré mirando de todas formas por si acaso

Muchas gracias.
Un saludo

Buenos dias.

He llamado pareja a cuando tienen 2 cartas del mismo número.
En el caso del jugador 1 sería seis de tréboles y 6 de diamantes.
En el caso del jugador 2 sería nueve de espadas y nueve de treboles.

Asique hasta  ese punto todo está correcto. El problema viene después. Una vez que ha mostrado que mano tiene cada jugador, debería decir quien de los 2 ha ganado y es lo que no hace.
De hecho estuve comprobando hasta donde llegaba el programa antes de fallar. unas veces llega hasta el inicio de la funcion 'determina_ganador' y otras ni siquiera llega a entrar en esa función.
Por eso puse que se mostrara el texto "Por aquí" antes de entrar en esa función, y el texto "Jugadores = 2" cuando entraba en esa función.
Pero aún entrando en esa función, no llega a mostrar quien gana.

Todo esto me hace pensar que el problema debe de estar o en la función 'almacena_resultados' o en 'determina_ganador'.

El programa está organizado de la siguiente manera:

la función 'baraja' asigna un número a cada una de las 52 cartas, por lo que cada vez que busco una carta tengo que hacer la pasada por todo el mazo hasta que encuentra dicho número.

la función 'reparte' asigna 5 cartas al jugador.

la función 'combinacion_mano' imprime las 5 cartas del jugador y determina que tipo de jugada tiene(jugadas de poker).

la función 'almacena_resultados': entro a ella al final de 'combinación_mano' y guarda en el arreglo 'resultados'  el tipo de jugada y el número de la carta de la jugada (por ejemplo: pareja de 7).

la funcion 'determina_ganador' va analizando el arreglo 'resultados' de arriba a abajo (de mejor jugada a peor). Cuando encuentra un valor distinto de -1, almacena los valores en una variable, compara a ver si alguien más tiene esa jugada y de ser así compara a ver quien tiene la carta de mayor número.
Tras todo esto debería imprimir el jugador ganador y el tipo de jugada.
Pero no lo hace 

Muchas gracias por la ayuda
Un saludo

p.d. El arreglo resultados hay que inicializarlo en -1, que yo lo hice todo en 0. Lo he cambiado en el programa pero sigue sin funcionar. Intente modificar el código aquí en el foro pero no me deja, por eso lo aviso por aquí.

Muchas gracias.
El ide sería para linux ubuntu.
A no ser que me recomiendes algún otro para ubuntu me instalaré code blocks que he leído que ralentiza menos el equipo.

Un saludo

Buenas tardes.
Como me viene pasando ultimamente cuando hago algo de recursividad, los resultados no son los esperados.
El código es el siguiente:
// Ejercicio 6.35: Búsqueda binaria (recursivo) //

#include <stdio.h>
#define TAMANIO 15

/* prototipos de las funciones */
int busquedaBinaria( const int b[], int claveDeBusqueda, int bajo, int alto );
void despliegaEncabezado( void );
void despliegaLinea( const int b[], int bajo, int medio, int alto );

/* la función main comienza la ejecución del programa */
int main()
{
   int a[ TAMANIO ]; /* crea el arreglo a */
   int i; /* contador para inicializar los elementos de 0 a 14 del arreglo a */
   int llave; /* valor a localizar en el arreglo a */
   int resultado; /* variable para almacenar la ubicación de la llave o -1 */

   /* crea los datos */
   for ( i = 0; i < TAMANIO; i++ ) {
      a[ i ] = 2 * i;
   } /* fin de for */

   printf( "Introduzca un numero entre 0 y 28: " );
   scanf( "%d", &llave );

   despliegaEncabezado();

   /* busca la llave en el arreglo a */
   resultado = busquedaBinaria( a, llave, 0, TAMANIO - 1 );

   /* despliega los resultados */
   if ( resultado != -1 ) {
      printf( "\n%d se encuentra en el elemento %d del arreglo\n", llave, resultado );
   } /* fin de if */
   else {
      printf( "\n%d no se encuentra\n", llave );
   } /* fin de else */

   system("pause");
   return 0; /* indica terminación exitosa */

} /* fin de main */

/* función para realizar la búsqueda binaria en un arreglo */
int busquedaBinaria( const int b[], int claveDeBusqueda, int bajo, int alto )
{
     int central = ( bajo + alto ) / 2;
     despliegaLinea( b, bajo, central, alto );


     if ( bajo > alto )
     {
        printf("\ncentral = %d", central);
          return -1;
     }

     if ( claveDeBusqueda == b[ central ] )
     {
         printf("\ncentral = %d", central);
         return -1;
     }

     if ( claveDeBusqueda < b[ central ] )
     {
         busquedaBinaria( b, claveDeBusqueda, bajo, central - 1 );
     }

     if(claveDeBusqueda > b[central] )
     {
         busquedaBinaria (b, claveDeBusqueda, central + 1, alto);
     }

} /* fin de la funcipon busquedaBinaria */

/* Imprime un encabezado para la salida */
void despliegaEncabezado( void )
{
   int i; /* contador */

   printf( "\nSubindices:\n" );

   /* muestra el encabezado de la columna */
   for ( i = 0; i < TAMANIO; i++ ) {
      printf( "%3d ", i );
   } /* fin de for */

   printf( "\n" ); /* comienza la nueva línea de salida */

   /* muestra una línea de caracteres  - */
   for ( i = 1; i <= 4 * TAMANIO; i++ ) {
      printf( "-" );
   } /* fin de for */

   printf( "\n" ); /* inicia una nueva línea de salida */
} /* fin de la función despliegaEncabezado */

/* Imprime una línea de salida que muestra la parte actual
   del arreglo que se esta procesando. */
void despliegaLinea( const int b[], int baj, int cen, int alt )
{
   int i; /* contador para la iteración a través del arreglo b */

   /* ciclo a través del arreglo completo */
   for ( i = 0; i < TAMANIO; i++ ) {

      /* despliega espacios si se encuentra fuera del rango actual del subarreglo */
      if ( i < baj || i > alt ) {
         printf( "    " );
      } /* fin de if */
      else if ( i == cen ) { /* despliega el elemento central */
         printf( "%3d*", b[ i ] ); /* marca el valor central */
      } /* fin de else if */
      else { /* despliega otros elementos en el subarreglo */
         printf( "%3d ", b[ i ] );
      } /* fin de else */

   } /* fin de for */

   printf( "\n" ); /* inicia la nueva línea de salida */
} /* fin de la función despliegaLinea */


He probado introduciendo el número 25, y en vez de mostrar que no se encuentra el número, muestra que se ha encontrado, lo cual no me cuadra, porque si que devuelve -1 a la funcion main.
Otro caso es, si introduzco el número 8, devuelve a la función main el 8, pero al mostrar el resultado, aparece como si fuera 14. Y con el 6 ocurre lo mismo.
A ver si alguien me pudiera ayudar.
Muchisimas gracias

He estado mirando en entornos de desarrollo para ubuntu, y los que más me han convencido son codeblocks, eclipse y anjuta. Da lo mismo usar uno que otro? ventajas o desventajas de alguno de ellos?. Esque estoy empezando con la programación por mi cuenta y además me instale linux hace nada asique estoy perdido por partida doble ejejeje.
Muchas gracias por toda tu ayuda.
Un saludo

Muchas gracias.

He probado tu código y me da el mismo resultado que en lo que yo modifiqué (2686324).
Asique supongo que será problema del compilador.

Uso dev-c++. Sabes alguna forma para que lo pudiera arreglar.

Muchas gracias