Você está aqui: C ::: Estruturas de Dados ::: Lista Ligada Simples |
Inserindo depois de um determinado nó em uma lista encadeada simples usando a linguagem CQuantidade de visualizações: 1417 vezes |
Inserindo depois de um determinado nó em uma lista encadeada simples usando C Em algumas situações nós precisamos inserir o novo nó depois de um determinado nó na lista encadeada simples. Veja, por exemplo, uma lista com o seguintes valores: 45 | 3 | 98 | 47 Suponha que queremos inserir o valor 50 depois do 98, então o novo conteúdo da lista será: 45 | 3 | 98 | 50 | 47 Observe que neste exemplo eu tratei o caso de inserir depois do primeiro nó, ou seja, depois do 45, mas não tratei a lista vazia. Há também a questão do erro de acesso de memória caso o usuário queira inserir depois de um nó não existente (não tratada). Veja o código completo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> // estrutura Nó struct No{ int valor; struct No *proximo; }; // fim da estrutura Nó // função que permite exibir os valores de // todos os nós da lista void exibir(struct No *n){ if(n != NULL){ do{ printf("%d\n", n->valor); n = n->proximo; }while(n != NULL); } else printf("A lista esta vazia\n\n"); } // função que permite inserir um novo nó // depois de um determinado valor struct No *inserir_depois_valor(struct No *n, int v, int v_depois){ // reserva memória para o novo nó struct No *novo = (struct No*)malloc(sizeof(struct No)); novo->valor = v; struct No *temp = n; // aponta para o início da lista // guarda o nó depois do nó atual struct No *depois = temp; // enquanto for diferente do valor que estamos procurando while(depois->valor != v_depois){ depois = temp; // depois recebe temp // e temp recebe o seu próximo temp = temp->proximo; } // ATENÇÃO: não estamos tratando a condição // de lista vazia. Para isso veja minha dica // sobre como inserior no início da lista // vamos inserir depois do primeiro nó if(depois == n){ // o próximo do novo nó aponta para // o segundo nó novo->proximo = n->proximo; // o primeiro nó aponta para o novo nó n->proximo = novo; } else{ // o proximo do anterior é o novo nó depois->proximo = novo; // e o próximo do novo nó é temp novo->proximo = temp; } return n; } // função que permite inserir nós no // final da lista. // veja que a função recebe o valor a ser // armazenado em cada nó e um ponteiro para o // início da lista. A função retorna um // ponteiro para o início da lista struct No *inserir_final(struct No *n, int v){ // reserva memória para o novo nó struct No *novo = (struct No*)malloc(sizeof(struct No)); novo->valor = v; // verifica se a lista está vazia if(n == NULL){ // é o primeiro nó...não deve apontar para // lugar nenhum novo->proximo = NULL; return novo; // vamos retornar o novo nó como sendo o início da lista } else{ // não está vazia....vamos inserir o nó no final // o primeiro passo é chegarmos ao final da lista struct No *temp = n; // vamos obter uma referência ao primeiro nó // vamos varrer a lista até chegarmos ao último nó while(temp->proximo != NULL){ temp = temp->proximo; } // na saída do laço temp aponta para o último nó da lista // novo será o último nó da lista...o campo próximo dele deve // apontar para NULL novo->proximo = NULL; // vamos fazer o último nó apontar para o nó recém-criado temp->proximo = novo; return n; // vamos retornar o início da lista intacto } } int main(int argc, char *argv[]) { // declara a lista struct No *inicio = NULL; // vamos inserir quatro valores no final // da lista inicio = inserir_final(inicio, 45); inicio = inserir_final(inicio, 3); inicio = inserir_final(inicio, 98); inicio = inserir_final(inicio, 47); // vamos exibir a lista puts("Valores atuais:\n"); exibir(inicio); // vamos inserir o valor 50 depois do 3 inicio = inserir_depois_valor(inicio, 50, 3); // vamos exibir a lista novamente puts("\nValores agora:\n"); exibir(inicio); puts("\n\n"); system("pause"); return 0; } |
![]() |
C ::: C para Engenharia ::: Física - Mecânica |
Como calcular a Energia Potencial Gravitacional de um corpo dado a sua massa e altura em CQuantidade de visualizações: 2063 vezes |
A Energia Potencial Gravitacional ou Energia Gravitacional é a energia potencial que um objeto massivo tem em relação a outro objeto massivo devido à gravidade. É a energia potencial associada ao campo gravitacional, que é parcialmente convertida em energia cinética quando os objetos caem uns contra os outros. A energia potencial gravitacional aumenta quando dois objetos são separados. A fórmula para obtenção da Energia Potencial Gravitacional de um corpo em relação à sua massa e distância do chão, ou seja, da superfície terrestre, é: \[ E_\text{pg} = \text{m} \cdot \text{g} \cdot \text{h} \] Onde: Epg ? energia potencial gravitacional (em joule, J). m ? massa do corpo (em kg). g ? aceleração da gravidade (m/s2). h ? altura do objeto em relação ao chão (em metros). Como podemos ver, a Energia Potencial Gravitacional está diretamente relacionada à distância do corpo em relação à superfície terrestre. Dessa forma, quanto mais distante da terra o objeto estiver, maior a sua energia gravitacional. Isso nós diz também que, um objeto de altura zero possui Energia Potencial Gravitacional nula. Vamos ver um exemplo agora? Observe o seguinte enunciado: 1) Uma pessoa levanta um tijolo com peso de 2 quilogramas à distância de 1,5 metros do chão. Qual é a Energia Potencial Gravitacional deste corpo? Como o exercício nos dá a massa do objeto em kg e a distância dele em relação ao chão já está em metros, tudo que temos a fazer é jogar na fórmula. Veja o código C completo para o cálculo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> // função principal do programa int main(int argc, char *argv[]){ // gravidade terrestre em m/s2 float gravidade = 9.80665; // massa do corpo float massa = 2; // em kg // altura do corpo em relação ao chão float altura = 1.5; // em metros // vamos calcular a energia potencial gravitacional float epg = massa * gravidade * altura; // mostramos o resultado printf("A Energia Potencial Gravitacional é: %fJ", epg); printf("\n\n"); system("PAUSE"); return 0; } Ao executar este código C nós teremos o seguinte resultado: A Energia Potencial Gravitacional é: 29.419950J |
C ::: Dicas & Truques ::: Matemática e Estatística |
Como usar a função modf() da linguagem C para separar um valor de ponto flutuante em suas partes inteira e fracionáriaQuantidade de visualizações: 9928 vezes |
Em algumas situações precisamos obter as partes inteira e fracionária de um valor de ponto flutuante. Para isso podemos usar a função modf(). Veja sua assinatura:---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- double modf(double x, double * intpart); O parâmetro x é o valor de ponto flutuante cujas partes queremos separar e intpart é uma variável do tipo double que receberá a parte inteira do valor. O retorno da função é o valor fracionário. Vamos ver um exemplo? Veja como podemos quebrar o valor 34,27 em suas partes inteira e fracionária: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { double valor = 34.27; // vamos separar o valor em suas partes inteira e fracionária double inteira = 0.0, fracionaria = 0.0; fracionaria = modf(valor, &inteira); // vamos exibir o resultado printf("Parte inteira: %f\n", inteira); printf("Parte fracionaria: %f\n", fracionaria); printf("\n\n"); system("pause"); return 0; } Ao executarmos este código teremos o seguinte resultado: Parte inteira: 34.000000 Parte fracionária: 0.270000 |
C ::: Dicas & Truques ::: Ponteiros, Referências e Memória |
Apostila C para iniciantes - Como usar ponteiros na linguagem CQuantidade de visualizações: 32375 vezes |
Antes de pensarmos em ponteiros, é importante nos lembrarmos de alguns aspectos referentes à variáveis. Dependendo do seu conhecimento de programação, você deve saber que variáveis possuem nomes que as identificam durante a execução do programa. Você deve saber também que uma variável armazena um valor (que pode ser fixo, no caso de uma constante, ou pode mudar durante a execução de seus códigos). O que poucos programadores se lembram é que uma variável possui um endereço, e que o nome da variável não é nada mais que um apelido para a localização deste endereço. Desta forma, um ponteiro não é nada mais que um tipo especial de variável que armazena o endereço de outra. Veja um exemplo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- #include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { // variável do tipo int int valor = 10; // ponteiro para uma variável do tipo int int *p = &valor; // exibe o valor da variável "valor", apontada // pelo ponteiro p printf("%d", *p); printf("\n\n"); system("PAUSE"); return 0; } Neste código nós temos a declaração e definição de duas variáveis: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- int valor = 10; int *p = &valor; A primeira variável é uma variável do tipo int e a segunda é um ponteiro para uma variável do tipo int. Veja que devemos sempre usar "*" antes do nome de um ponteiro em sua declaração. O símbolo "&" serve para indicar que estamos acessando o endereço de uma variável e não o seu conteúdo. O resultado destas duas linhas é que agora temos um ponteiro que nos permite acessar e manipular a variável valor. Observe a linha: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- printf("%d", *p); Aqui nós estamos acessando o valor da variável apontada por p. Veja o uso do símbolo "*" para acessar o valor da variável. Isso é chamado de desreferenciamento de ponteiros. Pareceu complicado? Veja uma linha de código que altera indiretamente o valor da variável valor para 30: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- *p = 30; Ponteiros são ferramentas muito importantes na programação em C. No entanto, é preciso ter muito cuidado ao lidar com eles. A primeira coisa a ter em mente é que um ponteiro não está apontando para nenhum lugar até que atribuimos a ele o endereço de uma outra variável. E é aí que mora o perigo. Um programa entra em colapso absoluto se tentarmos acessar um ponteiro que aponta para um local de memória que já foi liberado novamente ao sistema. No caso menos grave, estaremos tentando acessar locais de memória inválidos ou reservados a outros programas ou tarefas do sistema operacional. Isso me lembra os velhos tempos da tela azul de morte. |
Desafios, Exercícios e Algoritmos Resolvidos de C |
Veja mais Dicas e truques de C |
Dicas e truques de outras linguagens |
Códigos Fonte |
![]() Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais |
![]() Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais |
Linguagens Mais Populares |
1º lugar: Java |