Beispiel #1
0
void ins_lst( char x_nome[], no_tipo * *L )
 { /* L eh criada com todos os campos.... mas
		nao houve atribuicoes... portanto cuidar...
	*/
	no_tipo * novo_no ;
	novo_no = cria_no ();

	if ((strcpy( novo_no -> nome , x_nome)) == "\0")
	{  /* strcpy returns destino  * char */
		printf("\n Problema na insercao.... na copia do nome");
		getche();
		exit(1);
	}

if ( *L == NULL )
	/* L -> next dah erro */
	/* pois nao hah criacao/alocacao do mesmo na PILHA e HEAP */
		{ /* A LISTA ESTAVA VAZIA ===> 1o. elemento ATERRAR */
			novo_no -> next = NULL;
		}
		else
		{ /* posiciona ateh o fim ===> insercao no inicio */
			novo_no -> next = *L ;
		}
		* L = novo_no;   /* ATUALIZA CABECA ...*/
		printf ("\n Conteudo:: %x Onde estah:: %x. Conteudo Indireto %x:: ", L, &L, *L);
		return;
}
Beispiel #2
0
dupla * cria_lista(void)
{
	dupla *L;
	L = cria_no ();  /* criando a lista na HEAP */
	L -> next = NULL; /* aterrando */
	return (L);
}
apontador insere (apontador p, int chave)
{
	if(p==null)
		return cria_no(chave);
	else if (p->chave > chave)
		p->esq = insere(p->esq, chave);
	else
		p->dir = insere(p->dir, chave);
	return p;
}
Beispiel #4
0
/* adiciona uma aresta ao grafo*/
void grafo_adiciona(grafo *g, int origem, int dest)
{
    lista_no* novo;

    if (g == NULL || grafo_aresta(g, origem, dest))
        return;

    /* adiciona uma aresta de origem para dest na lista de adjacencias */
    novo = cria_no(dest);
    novo->proximo = g->adjacencias[origem].inicio;
    g->adjacencias[origem].inicio = novo;
    g->adjacencias[origem].tamanho++;
 
    if(g->tipo == NAODIRECIONADO)
    {
        /* adiciona tambem aresta de dest para origem */
        novo = cria_no(origem);
        novo->proximo = g->adjacencias[dest].inicio;
        g->adjacencias[dest].inicio = novo;
        g->adjacencias[dest].tamanho++;
    }
}
Beispiel #5
0
//proc. que insere no----------------------------------------------------------------------------------
parvore insere_no(parvore *raiz, tcod cod) {
				parvore ant, atual;

				if (vazia(*raiz)) {
							*raiz = cria_no(cod);
							(*raiz) -> pai = NULL; // a raiz da arvore possui "pai = NULL "
							return((*raiz));
				}
				else {
								atual = (*raiz);
								while (atual != NULL) {
											if (cod == atual -> cod) {
													printf(" O valor e chave ja existe na arvore ");
													return (NULL);
											}
											 else {
															ant = atual;
															if (maior(atual -> cod, cod))
																	atual = atual -> esq;
															else
																	atual = atual -> dir;
											 }
								 }
								 if ( maior(ant -> cod, cod) ) {
												ant -> esq = cria_no(cod);
												ant -> esq -> pai = ant;
												return ( ant -> esq);
								 }
								 else {
												ant -> dir = cria_no(cod);
												ant -> dir -> pai = ant;
												return (ant -> dir);
								 }

				}
 }
Beispiel #6
0
noh_id *  ins_inic(int x, noh_id * L)
{
	noh_id  * novo;
	novo = cria_no();

	novo -> idade = x; /* atribui valor */

 if( L == NULL) /* no caso de nada na HEAP */
 {
	novo -> next =  NULL;
	L = novo;
	return (L);
 }
 /* INSERE NO INICIO ==> SEMPRE */
	novo -> next = L ;
	return (novo) ;
}
Beispiel #7
0
 void insere(int x, dupla *&L)
 {
    dupla *aux, *novo_no, *ultimo;
    aux=L;
    ultimo=L->prior;
    novo_no  = cria_no();
    if (aux==NULL)
    {
       novo_no->idade=x;
       novo_no->next=novo_no;
       novo_no->prior=novo_no;
       L=novo_no;
       return;
    }
    novo_no->idade=x;
    novo_no->next=L;
    ultimo -> next =   novo_no;
    novo_no ->  prior  = ultimo ;
    L->prior=novo_no;
    return;
 }