Ir ao conteúdo
  • Cadastre-se

Gerar números aleatórios e ordena los ate 1 bilhão


du_violin

Posts recomendados

você quer reservar varios bilhões de inteiros na pilha da função? Espero que esteja usando memoria dinâmica si nao nao dai ser possível >_<, a pilha esta limitada a 2 MB mais ou menos en cada função, depende do compilador e sistema.

A função rand igualmente devolve um inteiro, haveria que ver si a função rand é capaz de gerar números assim de grandes, si nao você teria que construir sua propria função rand para que retornasse insigned int ou long long int.

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

#define N 490000000
int vetor[N],i;
/**função principal**/
int main()
{
    for(i=0; i<N; i++)
        vetor[i]=i+1;

    enbaralhar();
    ordena();
}
/**funçao de enbaralhar os numeros**/
int enbaralhar()
{
    int escolha = 0,rand_num = N,pos_vetor = 0,tmp;
    while( pos_vetor < N - 1 )
    {
        /** Escolhe uma posicao aleatoria **/
        escolha = rand() % rand_num;
        /** Faz a troca pela posicao sequencial **/
        tmp = vetor[pos_vetor];
        vetor[pos_vetor] = vetor[escolha];
        vetor[escolha] = tmp;
        /** Proxima posicao que sera trocada **/
        pos_vetor++;
    }
    /** Mostra o vetor embaralhado **/
    printf("---------------------------");
    printf("|   numeros enbaralhados  |");
    printf("-------------------------\n");
    for( i = 0; i< N; i++)
        printf("\t%d", vetor[i]);
    printf("\n");
    //system ("pause");
}
/** ordenaçao do vetor aleatorio**/
int ordena()
{
    int B[N],x;
    printf("---------------------------");
    printf("|     numeros ordenados    |");
    printf("---------------------------\n");
    for( i = 1; i<=N; i++)
    {
        x=vetor[i];
        while(vetor[x] != (i))
        {
            x++;
        }
        B[i] = vetor[x];
        printf("\t%d", B[i]);

    }
}

 

 

   

 

Link para o comentário
Compartilhar em outros sites

@du_violin Não precisa refazer o post, é só editar.

Seu código estava cheio de erros, dos mais diversos... dei uma moldada nele.

 

#include<stdio.h>
#include<stdlib.h>
//#include<time.h>
#define N 500000000

void enbaralhar();
void vet();
void ordena( int *p );

int vetor[N], i;


int main() {
  enbaralhar();

  return 0;
}

void vet() {
  for ( i = 0; i < N; i++ ) {
    vetor[i] = i + 1;
  }
}

void enbaralhar() {
  int escolha = 0, rand_num = N, pos_vetor = 0, tmp;
  vet();
  while ( pos_vetor < N - 1 ) {

    escolha = rand() % rand_num;

    tmp = vetor[pos_vetor];
    vetor[pos_vetor] = vetor[escolha];
    vetor[escolha] = tmp;

    pos_vetor++;
  }

  printf( "NUMEROS embaralhadOs: \n" );
  for ( i = 0; i < N; i++ )
    printf( "\t%d", vetor );
  printf( "\n" );
  system( "pause" );
  ordena( vetor );
  return ;
}

void ordena( int *p ) {
  int B[N], x;
  printf( "numeroos ordenados \n" );
  for ( i = 1; i <= N; i++ ) {
    x = vetor[i];
    while ( vetor[x] != ( i ) ) {
      x++;
    }
    B[i] = vetor[x];
    printf( "\t%d", B );
  }
}

 

Link para o comentário
Compartilhar em outros sites

@du_violin Seu número é muito grande e vai demorar bastante pra processar.



Correção:

#define N 20
int vetor[N],i;

/**funçao de enbaralhar os numeros**/
int enbaralhar()
{
    int escolha = 0,rand_num = N,pos_vetor = 0,tmp;
    while( pos_vetor < N - 1 )
    {
        /** Escolhe uma posicao aleatoria **/
        escolha = rand() % rand_num;
        /** Faz a troca pela posicao sequencial **/
        tmp = vetor[pos_vetor];
        vetor[pos_vetor] = vetor[escolha];
        vetor[escolha] = tmp;
        /** Proxima posicao que sera trocada **/
        pos_vetor++;
    }
    /** Mostra o vetor embaralhado **/
    printf("---------------------------");
    printf("|   numeros enbaralhados  |");
    printf("-------------------------\n");
    for( i = 0; i< N; i++)
        printf("\t%d", vetor[i]);
    printf("\n");
    //system ("pause");
}
/** ordenaçao do vetor aleatorio**/
int ordena()
{
    int B[N],x;
    printf("---------------------------");
    printf("|     numeros ordenados    |");
    printf("---------------------------\n");
    for( i = 1; i<=N; i++)
    {
        x=0;  //<<---------------------- ERRO era aqui
        while(vetor[x] != i )
        {
            x++;

        }
        B[i] = vetor[x];
        printf("\t%d", B[i]);

    }
}
/**função principal**/
int main()
{
    for(i=0; i<N; i++)
        vetor[i]=i+1;

    enbaralhar();
    ordena();
}

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

@du_violin Seu algoritmo é muito lento pra ordenar o vetor se você for ordenar 1 bilhão com ele vai demorar anos... Além dos "printfs", esses sim atrasam muito o programa. Eu modifiquei ele para imprimir somente de mil em mil, compile e veja ele ordenando 500000 valores . Compile e rode isso:

 

#define N 500000
int vetor[N],i;

/**funçao de enbaralhar os numeros**/
int enbaralhar()
{
    int escolha = 0,rand_num = N,pos_vetor = 0,tmp;
    while( pos_vetor < N - 1 )
    {
        /** Escolhe uma posicao aleatoria **/
        escolha = rand() % rand_num;
        /** Faz a troca pela posicao sequencial **/
        tmp = vetor[pos_vetor];
        vetor[pos_vetor] = vetor[escolha];
        vetor[escolha] = tmp;
        /** Proxima posicao que sera trocada **/
        pos_vetor++;
    }
    /** Mostra o vetor embaralhado **/
    printf("---------------------------");
    printf("|   numeros enbaralhados  |");
    printf("-------------------------\n");
    for( i = 0; i< N; i++);
        printf("\t%d", vetor[i]);
    printf("\n");
    //system ("pause");
}
/** ordenaçao do vetor aleatorio**/
int ordena()
{
    int B[N],x;
    printf("---------------------------");
    printf("|     numeros ordenados    |");
    printf("---------------------------\n");
    for( i = 1; i<=N; i++)
    {
        x=0;  //<<---------------------- ERRO era aqui
        while(vetor[x] != i )
        {
            x++;

        }


        B[i] = vetor[x];
        if (B[i] % 1000 == 0)
          printf("\t%d", B[i]);

    }
}
/**função principal**/
int main()
{
    for(i=0; i<N; i++)
        vetor[i]=i+1;

    enbaralhar();
    ordena();
}

 

 

Agora uma ordenação dos mesmos 500000 mil valores, só que agora é uma ordenação no pior caso, compile e veja o resultado:

 

OSB: salve como arquivo.cpp

 

#include<cstdio>
#include<cstdlib>
#include<ctime>

void Shell_Sort (unsigned long int seq[], unsigned long int nelem);

unsigned long int N = 500000;

int main() {
  unsigned long int v[N], i= 0;
  unsigned long int  *L = new unsigned long int[N];
  srand(time(0));

  printf("Vetor Criado: ");
  for ( i = 0; i < N; i++){
    L[i] =  N - i;
    //printf("%d ", v[i]);
  }

  printf("\n\nVetor Ordenado: ");
  Shell_Sort(L, N);
  for ( i = 0; i < N; i++){

    if(L[i] % 1000 == 0)
    printf("%li ", L[i]);
  }

return 0;
}

void Shell_Sort (unsigned long int seq[], unsigned long int nelem)  /* 2 versao */
{
  unsigned int indi, indj, incremento;  int temp;

 for (incremento = nelem/2; incremento > 0; incremento /= 2)
   for (indi = incremento; indi < nelem; indi++)
   {
     temp = seq[indi];  /* copiar o elemento a ordenar */

    for (indj = indi; indj >= incremento; indj -= incremento)
      if (temp < seq[indj-incremento])
       seq[indj] = seq[indj-incremento];  /* deslocar elementos */
      else break;

    seq[indj] = temp;  /* inserir o elemento a ordenar na posicao */
   }
}

 

A diferença é notável...

Link para o comentário
Compartilhar em outros sites

@CiroboyBR  cara , eu quero rodar um bilhão, a princípio não importa os métodos de ordenação! conheço os metodos, o problema é rodar um bilhão... Só isso, o tempo que isso vai ficar rodando não tem muita importância a princípio!!! Mais qualquer e ajuda e bem vinda

 

 

Link para o comentário
Compartilhar em outros sites

@CiroboyBR

#include <stdlib.h>
#include <stdio.h>
#define N 100

int main()
{

    int*v,i;

    v = (int*) malloc(N*sizeof(int));

    for(i=0; i<N; i++)
    {
        v[i] = i;
    }

    embaralha(v);
    ordena(v);

    free(v);
    return 0;
}

int embaralha (int v[])
{
    int i, j, t;

    while (v[i] <N-1)
    {
        j = rand()%N;
        t = v[i];
        v[i] = v[j];
        v[j] = t;
        i++;
    }
    printf("numeros enbaralhados\n\n");
    for(i=0; i<N; i++)
    {
        printf("%d\t", v[i]);
    }

}

int ordena( int v[])
{
    int B[N],x,i;
    printf("\n\nnumeros ordenados");

    for( i = 1; i<=N; i++)
    {
        x=0;
        while(B[x] != i )
        {
            x++;

        }
        v[i] = B[x];
        printf("\t%d", v[i]);

    }

}

 

consegui!!!!! ta gerando 1 bilhao

Link para o comentário
Compartilhar em outros sites

Visitante
Este tópico está impedido de receber novas respostas.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...