Busca e ordenação de vetor

//Diretivas de pré processamento
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#define max 10

int busca_sequencial(int *, int *);
int busca_binaria(int *, int *);
void quick_crescente(int *, int, int);
void quick_decrescente(int *, int, int);
void bubble_crescente(int *, int);
void bubble_decrescente(int *, int);

//Função principal, onde o vetor é inicializado e se entra com uma valor
int main() {

    srand(time(NULL));

    //Embelezamento da tela
    system("color 70");

    //Declaração das variaveis
int vetor[max], i, j, valor, resultado;

    printf("Vetores: ");
    //Lê o vetor, ordenando-o de forma randômica
    for (i = 0; i<max; i++)
    {
        vetor[i] = rand() % 9;
        for (j = 0; j<i; j++)
            if (vetor[i] == vetor[j])
                vetor[i] = rand() % 9;
        printf("| %d ", vetor[i]);

    }
    printf("|\n\n");

    //Busca do vetor
    printf("Entre com um dos numeros acima: ");
    scanf("%d", &valor);

    //Redireciona a busca para uma função
    resultado = busca_sequencial(&vetor[0], &valor);
    //resultado = busca_binaria(&vetor[0], &valor);

    //Tras o resultado da posição
    if (resultado == -1)
        printf("Vetor nao encontrado\n");
    else
        printf("\nPosicao do vetor: %d\nVetor digitado: %d\n\n", resultado, valor);

    printf("Tecle [Enter] para ordenar o vetor.\n\n");
    _getch();
    printf("Comecando a ordenacao do vetor...\n\n");

    //Chama e pula para a função de ordenação do vetor
    //quick_crescente(&vetor[0], 0, max - 1);
    quick_decrescente(&vetor[0], 0, max - 1);
    //bubble_crescente(&vetor[0], max - 1);
    //bubble_decrescente(&vetor[0], max - 1);

    printf("Vetores ordenados: | ");
    //Lê o vetor já ordenado
    for (i = 0; i <= max; i++) {
        printf("%d | ", vetor[i]);
    }
    printf("|\n\n");

    system("pause");
    return 0;
}

//Busca de vetor pela forma sequencial
int busca_sequencial(int *vetor, int *valor)
{
    int maior, i, po = 0;

    maior = *vetor;



    for (i = 0; i < max; i++) {
        if (vetor[i] == *valor) {
            maior = vetor[i];
            po = i;
            return po;
        }
    }
}

//Busca de vetor pela forma binária
int busca_binaria(int *pt, int *val)
{
    int inf = 0, sup = max , meio;

    do {
        meio = (sup + inf) / 2;
        if (*val == pt[meio])
            return meio;
        if (*val < pt[meio])
            sup = meio - 1;
        else
            inf = meio + 1;
    } while (inf <= sup);
    return -1;
}

//Ordenação crescente por Quicksort
void quick_crescente(int *pt, int inicio, int fim) {

    int pivo, aux, i, j, meio;

    //Prepara as variaveis para a ordenação
    i = inicio;
    j = fim;

    meio = (int)((i + j) / 2);
    pivo = pt[meio];

    do {
        //Verifica se o inicio e o fim já chegaram no meio para poder terminarem
        while (pt[i] < pivo)
            i = i + 1;
        while (pt[j] > pivo)
            j = j - 1;

        //Troca as posições dos numeros do vetor, caso necessario | aux = Variavel auxiliar para guardar o vetor por um instante
        if (i <= j) {
            aux = pt[i];
            pt[i] = pt[j];
            pt[j] = aux;
            i = i + 1;
            j = j - 1;
        }
        //Condição de existencia, quando J e I forem iguais ou j > i o algoritmo pula fora
    } while (j > i);

    if (j > inicio)
        quick_crescente(pt, inicio, j);
    if (i < fim)
        quick_crescente(pt, i, fim);
}

//Ordenação decrescente por Quicksort
void quick_decrescente(int *pt, int inicio, int fim) {

    int pivo, aux, i, j, meio;

    //Prepara as variaveis para a ordenação
    i = inicio;
    j = fim;

    meio = (int)((i + j) / 2);
    pivo = pt[meio];

    do {
        //Verifica se o inicio e o fim já chegaram no meio para poder terminarem
        while (pt[i] > pivo)
            i = i - 1;
        while (pt[j] < pivo)
            j = j + 1;

        //Troca as posições dos numeros do vetor, caso necessario | aux = Variavel auxiliar para guardar o vetor por um instante
        if (i <= j) {
            aux = pt[i];
            pt[i] = pt[j];
            pt[j] = aux;
            i = i + 1;
            j = j - 1;
        }
        //Condição de existencia, quando J e I forem iguais ou j > i o algoritmo pula fora
    } while (j > i);

    if (j < inicio)
        quick_decrescente(pt, inicio, j);
    if (i > fim)
        quick_decrescente(pt, i, fim);
}

//Bubblesort em ordenação crescente
void bubble_crescente(int *pt, int tam){

    int i,j,r,aux;
    for(i=tam-1; i >= 1; i--)
    {
        for(j=0; j < i ; j++)
        {
            if(pt[j] > pt[j+1])
            {
                aux = pt[j];
                pt[j] = pt[j+1];
                pt[j+1] = aux;
            }
        }
    }
}

//Ordenação decrescente por Bubblesort
void bubble_decrescente(int *pt, int tam){

    int i,j,r,aux;
    for(i=0; i <= tam; i++)
    {
        for(j=i; j >= 0 ; j--)
        {
            if(pt[j] < pt[j+1])
            {
                aux = pt[j];
                pt[j] = pt[j+1];
                pt[j+1] = aux;
            }
        }
    }
}