#include <stdio.h>
#include <stdlib.h>
 
#define FALSE 0
#define TRUE !FALSE
typedef int Bool;
 
/* Algoritmo O(n^2). Analizando todos los casos. */
Bool f1(int *a, int x, int tam);
 
/* Algoritmo O(n*log(n)). Ordeno con quicksort y uso busqueda binaria "n" veces. Me queda 2*n*log(n) que es O(n*log(n))*/
Bool f2(int *a, int x, int tam);
void quicksort(int *, int, int);
void pivot(int *, int, int, int *);
void swap(int *, int, int);
 
int main()
{
	int tam, contador, x;
	Bool b;
 
	printf("Ingrese 'x': ");
	scanf("%d", &x);
	printf("Tamaño del array (>=2): ");
	scanf("%d", &tam);
	int *a = (int *) calloc (tam, sizeof(int));
 
	for(contador=0; contador<tam; contador++)
	{
		printf("Ingrese el contenido de la celda %d: ", contador);
		scanf("%d", &a[contador]);
	}
 
	printf("\n\n");
	for(contador=0; contador<tam; contador++)
		printf("%d  ", a[contador]);
 
/* ********************************************** */
	b = f2(a, x, tam); /* solo cambiar "f1" por "f2" para cambiar de algoritmos */
	if(b == TRUE)
		printf("\n\nHay solucion\n");
	else
		printf("\n\nNo hay solucion\n");
/* ********************************************** */
 
	free(a);
	a=NULL;
 
	system("pause");
	return 0;
}
 
/* Algoritmo O(n^2). Analizando todos los casos. */
Bool f1(int *a, int x, int tam)
{
	Bool b=FALSE;
	int i, j;
	for(i=0; i<tam; i++)
		for(j=0; j<tam; j++)
			if(a[j]+a[i] == x)
				return b=TRUE; /* solución encontrada */
 
	return b; /* no hay solución */
}
 
/* Algoritmo O(n*log(n)). Ordeno con quicksort y uso busqueda binaria "n" veces. */
Bool f2(int *a, int x, int tam)
{
	quicksort(a, 0, tam-1);
 
	Bool b = FALSE;
	int izq=0, med, der=tam-1, k=0;
 
	while(izq<=der && !b && k<tam)
	{
		med = (izq+der)/2;
 
		if( x<(a[k]+a[med]) )
			der = med;
		else if ( x>(a[k]+a[med]) )
			izq = med;
		else if ( x==(a[k]+a[med]) )
			return b=TRUE; /* hay solución */
 
		k++;
	}
 
	return b; /* no hay solución */	
}
 
void quicksort(int *a, int izq, int der)
{
	int piv;
	if(izq<der)
	{
		pivot(a, izq, der, &piv);
		/* { Para todo x en a: a[izq,piv] son <= a[piv] && */
		/* Para todo x en a: a[piv+1,der] son > a[piv] } */
		quicksort(a, izq, piv-1);
		quicksort(a, piv+1, der);
	}
}
 
void pivot(int *a, int izq, int der, int *piv)
{
	int i = izq+1;
	int j = der;
	*piv = izq;
 
	while(i <= j)
	{
		/* { *piv<i<=j+1 && (Para todo x en a: a[izq,i]<=a[*piv]) && (Para todo x en a: a[j+1,der] > a[*piv]) } */
		if(a[i] <= a[*piv])
			i=i+1;
		else if(a[j] > a[*piv])
			j=j-1;
		else if(a[i] > a[*piv] && a[j] <= a[*piv])
		{
			swap(a, i, j);
			i = i+1;
			j = j+1;
		}
	}
	/* i vale j+1, (Para todo x en a: a[izq,j] <= a[*piv]) && (Para todo x en a: a[i,der] > a[piv] */
 
	/* dejando el pivot en una posición más central */
	swap(a, *piv, j);
	/* nueva posición para pivot */
	*piv = j;
}
 
void swap(int *a, int i, int j)
{
	int aux = a[i];
	a[i] = a[j];
	a[j] = aux;
}

¿Existen un a[i] y un a[j] tal que a[i]+a[j] = x?
Verdadero. En particular, a[1]+a[2] = 5.
 

#include <stdio.h>
#include <stdlib.h>
void busqueda(signed int array[], signed int n_elementos, signed int numero);
int main()
{
    signed int n_elementos, numero_usuario;
    do
    {
    printf("\nNumero de elementos : ");
    setbuf(stdin, NULL);
    } while(scanf("%d", &n_elementos) != 1);
    signed int *array = (int *)malloc(n_elementos * sizeof(int));
    for(signed int i = 0; i < n_elementos; i++)
    {
        printf("array[%d] = ", i);
        scanf("%i", &array[i]);
    }
    do
    {
    printf("Numero : ");
    setbuf(stdin, NULL);
    } while(scanf("%d", &numero_usuario) != 1);
    busqueda(array, n_elementos, numero_usuario);
    return 0;
}
void busqueda(signed int array[], signed int n_elementos, signed int numero_usuario)
{
    for(signed int i = 0; i < n_elementos; i++)
        for(signed int j = 0; j < n_elementos; j++)
            if(array[i] + array[j] == numero_usuario)
                printf("array[%d] + array[%d] = %d\n", i, j, numero_usuario);
}