Mesclar e centralizar uma lista vinculada em C++

//Programa C para mesclar uma lista vinculada em outro nas
//posições alternativas
#include <stdio.h>
#include <stdlib.h>
// Um nó da lista aninhada

struct Node{
    int data;
    struct Node *next;
};
/* Função para inserir um nó no início*/

void push(struct Node ** head_ref, int new_data){

    struct Node* new_node =

           (struct Node*) malloc(sizeof(struct Node));

    new_node->data  = new_data;

    new_node->next = (*head_ref);

    (*head_ref)  = new_node;

}
/* Função de utilitário para imprimir uma lista ligada individualmente */

void printList(struct Node *head)

{

    struct Node *temp = head;

    while (temp != NULL)

    {

        printf("%d ", temp->data);

        temp = temp->next;

    }
    printf("\n");
}

// Função principal que insere nós da lista vinculada q em p em

// posições alternativas. Como o chefe da primeira lista nunca muda

// e o cabeçalho da segunda lista pode mudar, precisamos de um único ponteiro

// para primeira lista e ponteiro duplo para a segunda lista.

void merge(struct Node *p, struct Node **q){

     struct Node *p_curr = p, *q_curr = *q;
     struct Node *p_next, *q_next;
     // Embora existam posições disponíveis em p

     while (p_curr != NULL && q_curr != NULL)

     {

         // Salve os ponteiros seguintes

         p_next = p_curr->next;

         q_next = q_curr->next;



         //

         q_curr->next = p_next;  // Alterar o próximo ponteiro de q_curr

         p_curr->next = q_curr;  // Alterar o próximo ponteiro de p_curr



         //Atualize as dicas atuais para a próxima iteração

         p_curr = p_next;

         q_curr = q_next;

    }
    *q = q_curr; //Atualize o ponteiro principal da segunda lista
}
//Programa de driver para testar funções acima

int main()

{

     struct Node *p = NULL, *q = NULL;

     push(&p, 3);

     push(&p, 2);

     push(&p, 1);

     printf("Primeira lista vinculada:\n");

     printList(p);



     push(&q, 8);

     push(&q, 7);

     push(&q, 6);

     push(&q, 5);

     push(&q, 4);

     printf("Segunda lista vinculada :\n");

     printList(q);


     merge(p, &q);


     printf("\nPrimeira lista alterada modificada :\n\n");

     printList(p);


     printf("\nSegunda lista vinculada modificada :\n");

     printList(q);


     getchar();

     return 0;

}

Algoritmo Lista em C/C++

Objetivo : Inserir elementos no inicio da lista, no fim da lista, inserir em posição qualquer da lista, remover em posição qualquer da lista.

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

typedef struct celulalista{
int informacao;
struct celulalista *proximo;
}celula;

void iniciar_Lista(celula *pRecebido);
void inserir_Inicio(celula *pRecebido);
void Consultar(celula *pRecebido);
void remove_inicio(celula *pRecebido);
int levalor(int *valorrecebido);
void insere_qualquer(celula *pRecebido);
void busca_e_remove(celula *pRecebido);
void insert_Fim(celula *pRecebido);
void remove_Fim(celula *pRecebido);
void removeElementoListaFim(celula **pRecebido);

int main()
{
//Declaracoes
celula *pLista;
int opcao=0;

//pLista = (celula *)malloc(sizeof(struct celulalista));

pLista = new celulalista;
iniciar_Lista(pLista);
for(;;)
{
cout<<"\n\t1 - Inserir no inicio: ";
cout<<"\n\t2 - Consultar : ";
cout<<"\n\t3 - Remover no inicio: ";
cout<<"\n\t4 - Inserir em posicao qualquer : ";
cout<<"\n\t5 - Remover em posicao qualquer : ";
cout<<"\n\t6 - Inserir no final : ";
cout<<"\n\t7 - Remover no final : ";
cout<<"\n\t8 - Sair : \n\t";
cin>>opcao;
opcao = levalor(&opcao);
switch(opcao)
{
case 1:
inserir_Inicio(pLista);
break;
case 2:
Consultar(pLista);
break;
case 3:
remove_inicio(pLista);
break;
case 4:
insere_qualquer(pLista);
break;
case 5:
busca_e_remove(pLista);
break;
case 6:
insert_Fim(pLista);
break;
case 7:
removeElementoListaFim(&pLista);
break;
case 8:
exit(0);
}
}
return 0;
}
/*
Inicializacao da lista encadeada
*/

void iniciar_Lista(celula *pRecebido){
(pRecebido)->proximo = NULL;
}
/*
Funcao para insercao no inicio
*/

void inserir_Inicio(celula *pRecebido){
//Declaracoes
celula *temporario;
int valor;
//Instrucoes
cout<<"\n\tInforme um valor a ser inserido : ";
cin>>valor;
temporario = (celula * )malloc(sizeof(celula));
temporario->informacao = valor;
temporario->proximo = (pRecebido)->proximo;
(pRecebido)->proximo = temporario;
}
/*
Funcao para percorrer elementos
*/
void Consultar(celula *pRecebido){
//Declaracoes
celula *temporario;
int i=0;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\tLista Vazia!\n";
}else{
temporario = (celula * )malloc(sizeof(celula));
temporario = (pRecebido)->proximo;
system("cls");
while(temporario!=NULL){
cout<<"\n\t"<<(i= i+1)<<": Valor : "<<temporario->informacao<<"\n";
temporario = temporario->proximo;
}
}
}
/*
Remove elemento da cabeca
*/
void remove_inicio(celula *pRecebido){
//Declaracoes
celula *temporario;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\n\tLista Vazia!";
}else{
temporario = (pRecebido)->proximo;
(pRecebido)->proximo = temporario->proximo;
free(temporario);
}
}

int levalor(int *valorrecebido){
//Declaracoes
//Instrucoes
while((*valorrecebido > 8 )|| (*valorrecebido < 1)){
cout<<"\n\tOpcao Invalida. Informe novamente : \n";
scanf("%d", &(*valorrecebido));
}
return (*valorrecebido);
}
// COMECEI A IMPLEMENTAR A PARTIR DAQUI

void insere_qualquer(celula *pRecebido){
// Declarações
celula *aux1, *aux2, *temporario;
int posicao, valor;

// Instruções
if((pRecebido)->proximo == NULL){
printf("\nA lista esta vazia!");
}else{
cout<<"\n\tDigite o valor a ser inserido apos o valor :";cin>>posicao;
cout<<"\n\tDigite o valor a ser inserido :";cin>>valor;

temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
aux1 = (pRecebido);
aux2 = (pRecebido)->proximo;
while (aux2 != NULL && aux2->informacao != posicao) {
aux1 = aux2;
aux2 = aux2->proximo;
}
temporario->proximo = aux2;
aux1->proximo = temporario; 
}
}

void busca_e_remove(celula *pRecebido){
// Declarações
celula *aux1, *aux2;
int posicao;
// Instruções
if((pRecebido)->proximo == NULL){
printf("\nA lista esta vazia!");
}else{
aux1 = (pRecebido);
aux2 = (pRecebido)->proximo;
cout<<"\n\tDigite o valor a ser removido : "; cin>>posicao;

while (aux2 != NULL && aux2->informacao != posicao){
aux1 = aux2;
aux2 = aux2->proximo;
}
if(aux2 != NULL){
aux1->proximo = aux2->proximo;
free(aux2);//liberar e evitar esvaziamento de memoria
}
}
}

void insert_Fim(celula *pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
temporario = (celula *)malloc(sizeof(celula));
if(!temporario){
printf("Lista Cheia!\n");
exit(1);
}else{
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
}
temporario->informacao = valor;
temporario->proximo = NULL;

if((pRecebido)->proximo == NULL){
(pRecebido)->proximo = temporario;
}else{
celula *tmp = (pRecebido)->proximo;

while(tmp->proximo != NULL)
tmp = tmp->proximo;
tmp->proximo = temporario;
}
}

void removeElementoListaFim(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista vazia\n\n");
}else{
celula *ultimo = (*pRecebido)->proximo,
*penultimo = (*pRecebido);

while(ultimo->proximo != NULL){
penultimo = ultimo;
ultimo = ultimo->proximo;
}
penultimo->proximo = NULL;
}
}

MÉTODO 2

#include <cstdlib>
#include <stdio.h>
#include <stdlib.h>

using namespace std;

typedef struct celulaLista{
   int informacao;
   struct celulaLista *proximo;
}celula;

void initLista(celula **pRecebido);
void insertListaInicio(celula **pRecebido);
void insertListaFim(celula **pRecebido);
void insertListaPosicao(celula **pRecebido);
void buscaListaSimples(celula **pRecebido);
void removeElementoListaInicio(celula **pRecebido);
void removeElementoListaFim(celula **pRecebido);
void removeElementoListaPosicao(celula **pRecebido);
int leValor(int *valorRecebido);

int main(){
// Declarações
celula *pLista;
int opcao = 0;
//pLista = (celula *)malloc(sizeof(struct celulaLista));
pLista = new celulaLista;
initLista(&pLista);
for(;;){
printf("\n1 - Inserir no Inicio: ");
printf("\n2 - Inserir no Final: ");
printf("\n3 - Inserir em qualquer posicao: ");
printf("\n4 - Consultar: ");
printf("\n5 - Remover do Inicio");
printf("\n6 - Remover do Final");
printf("\n7 - Remover de qualquer posicao");
printf("\n8 - Sair\n");
scanf("%d", &opcao);
opcao = leValor(&opcao);
switch(opcao)
{
case 1:
insertListaInicio(&pLista);
break;
case 2:
insertListaFim(&pLista);
  break;
case 3:
insertListaPosicao(&pLista);
  break;
case 4:
buscaListaSimples(&pLista);
break;
case 5:
removeElementoListaInicio(&pLista);
break;
case 6:
removeElementoListaFim(&pLista);
break;
case 7:
removeElementoListaPosicao(&pLista);
break;
case 8:
exit(0);
}
}
return 0;
}
/*
   Inicialização da Lista Encadeada
*/
void initLista(celula **pRecebido){
   (*pRecebido)->proximo = NULL;
}
/*
   Função para Inserção no Início
*/
void insertListaInicio(celula **pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
temporario->proximo = (*pRecebido)->proximo;
(*pRecebido)->proximo = temporario; 
}
/*
   Função para Inserção no Fim
*/
void insertListaFim(celula **pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
temporario = (celula *)malloc(sizeof(celula));
if(!temporario){
printf("Lista Cheia!\n");
exit(1);
}else{
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
}
temporario->informacao = valor;
temporario->proximo = NULL;

if((*pRecebido)->proximo == NULL){
(*pRecebido)->proximo = temporario;
}else{
celula *tmp = (*pRecebido)->proximo;

while(tmp->proximo != NULL)
tmp = tmp->proximo;
tmp->proximo = temporario;
}
}
/*
   Função para Inserção em Qualquer Posicao
*/
void insertListaPosicao(celula **pRecebido){
// Declarações
celula *p, *q, *temporario;
int posicao;
int valor;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}else{
printf("\nInserir apos a posicao : ");
scanf("%d", &posicao); 
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);

temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
p = (*pRecebido);
q = (*pRecebido)->proximo;
while (q != NULL && q->informacao != posicao) {
p = q;
q = q->proximo;
}
temporario->proximo = q;
p->proximo = temporario; 
}
}
/*
   Função para Percorrer Elementos
*/
void buscaListaSimples(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista Vazia!\n");
}
else{
temporario = (celula *)malloc(sizeof(celula));
temporario = (*pRecebido)->proximo;
while(temporario != NULL){
printf("Valor : %d\n", temporario->informacao);
temporario = temporario->proximo;
}
} 
}
/*
   Remove Elemento do Inicio
*/
void removeElementoListaInicio(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}
else{
temporario = (*pRecebido)->proximo;
(*pRecebido)->proximo = temporario->proximo;
free(temporario);
}
}
/*
   Remove Elemento do Fim
*/
void removeElementoListaFim(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista vazia\n\n");
}else{
celula *ultimo = (*pRecebido)->proximo,
*penultimo = (*pRecebido);

while(ultimo->proximo != NULL){
penultimo = ultimo;
ultimo = ultimo->proximo;
}
penultimo->proximo = NULL;
}
}
/*
   Remove Elemento de Qualquer Posicao
*/
void removeElementoListaPosicao(celula **pRecebido){
// Declarações
celula *p, *q;
int posicao;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}else{
p = (*pRecebido);
q = (*pRecebido)->proximo;
printf("\nRemover o valor : ");
scanf("%d", &posicao);
while (q != NULL && q->informacao != posicao){
p = q;
q = q->proximo;
}
if(q != NULL){
p->proximo = q->proximo;
free(q);
}
}
}
/*
   Opção para Validação da Entrada
*/
int leValor(int *valorRecebido){
   // Declarações
   // Instruções
while((*valorRecebido > 8) || (*valorRecebido < 1)){
printf("Opcao Invalida. Informe novamente : \n");
scanf("%d", &(*valorRecebido));
}
return(*valorRecebido);
}

Algoritmo método de Gauss Seidel C/C++

#include <stdio.h>
#include <math.h>
#define ERROR 0.001 // erro, precissao
#define N 3 // Tamanho da matriz (linhas do sistema linear)

void main (){
int i, j;

    // Declara a matriz com os coeficientes e respostas
    float A[N][N]   = {{3, -0.1, -0.2},
                       {0.1, 7, -0.3},
                       {0.3, -0.2, 10}};

    // Declara matriz com os resultados
    float b[N][1]  = {{7.85},
                      {-19.3},
                      {71.4},
  {15}};

    // Declarar o vetor de chute inicial
    float x[N][1] = {{0},
                     {0},
                     {0},
{0}};

    // Declara o vetor do x velho para calcular o erro
    float xAntigo[N][1] = {{0},
                          {0},
                          {0},
  {0}};

    // Declara bandeira que indica quando parar
    float xError[N][1] = {{0},
                        {0},
                        {0},
{0}};

    // Erro que vai pra 1 quando todos os esrros forem no minimo menor que o ERROR
    int erro = 0;

    // Loop do metodo
    do {

        // Loop para
        for (i = 0; i < N; i++) {
            float s = 0;

            // Calculando o somatorio do conjunto x das iterações
            //usando a regra de cramer
            for (j = 0; j < N; j++) {
                if (j != i)
                    s = s + A[i][j]*x[j][0];//lop para calcular o Ax
            }

            // Faz (bi - s) / Aii ser o x
            x[i][0] = ((b[i][0] - s)/ A[i][i]);//lop para calcular o B-somatorio / A

        }
        //criterio da convergencia
        for (i = 0; i<N; i++){
            xError[i][0] = (fabs((x[i][0]- xAntigo[i][0]) / x[i][0])) * 100;
            if (xError[i][0] >= ERROR){
                erro = 1;//erro como uma questão de parada
            }else{
                erro = 0;
            }
            xAntigo[i][0] = x[i][0];
        }

        printf("\n");

        for (i = 0; i <N; i++){
           printf("X%i = %f\t |Er| = %f\n",i+1, x[i][0], xError[i][0]);
        }

    } while (erro != 0);

}

Algoritmo método de Gauss C/C++

#include <stdio.h>
#include <stdlib.h>
#define N 3 //O numero de equações (linhas do sistema linear)

void main (){
    int i, j, k;
    float fator, soma;
    float X[N];
    float M[N][N+1] = {{3, -0.1, -0.2, 7.85},
                       {0.1, 7, -0.3, -19.3},
                       {0.3, -0.2, 10, 71.4}};

    for(i = 0; i<N; i++){
        for(j = 0; j<=N; j++){
            printf("|%.3f\t", M[i][j]);
        }
        printf("\n");
    }

// ELIMINACAO PROGRESSIVA
    for(k = 0; k<N-1; k++){//Laco exterior se refere a coluna pivo que se altera. (linha pivo ou equacao pivo = equacao referencial para as eliminacoes)
        for(i = (k+1); i<N; i++){//Este laco se refere as linhas que sofrerao as eliminacoes, que sempre iniciarao na linha seguinte da linha pivo
            fator = M[i][k] / M[k][k];//fator de correcao que sera multiplicada pela linha pivo
         
for(j=0; j<=N; j++){//loco interno se refere a cada coluna da linha que sofrerao modificacoes da linha i
                M[i][j] = M[i][j] - fator*M[k][j];
            }
        }
    }

    X[N-1] = M[N-1][N] / M[N-1][N-1]; // Primeria variavel que obtamos

    //Test
    printf("\n");
    for(i = 0; i<N; i++){
        for(j = 0; j<=N; j++){
            printf("|%.3f\t", M[i][j]);
        }
        printf("\n");
    }

// SUBSTITUICAO PROGRESSIVA
    for(i=N-2; i>=0; i--){  //Laco exterior se refere a linha que recebera os valores das variaveis ja encontradas para descobrirmos  as outras. Ela se inicia na penultima linha e vai ate a primeira

        soma = 0;

        for(j=(i+1); j<N; j++){     //Laco interno se refere as colunas da linha i
            soma = soma + M[i][j]*X[j]; // soma todos os numeros da linha que ja tem o valor de x
        }
        X[i] = (M[i][N] - soma)/M[i][i]; // Calcula o x da coluna i
    }

    printf("\nResultado: " );
    for(i=0; i<N; i++)
         printf("\nX%d = %f\n", i+1, X[i]);

}

Algoritmo Método da Bissecção C/C++

Em engenharia elétrica geralmente usam-se a leis de Kirchhoff para estudar o comportamento estacionário (que não varia com o tempo ) de circuitos elétricos. Um outro problema importante envolve os circuitos que são transientes por natureza e em que ocorrem variações temporais súbitas. Tal situação ocorre depois do fechamento da chave da figura abaixo.

A duração desse período está intimamente ligada às propriedades de armazenamento do capacitor e do indutor. O fluxo da corrente através do resistor causa uma queda de voltagem (VR) dada por:

VR = iR

Onde i é a corrente e R é a resistência do resistor.

Um indutor “resiste” a variações na corrente, de modo que a queda de tensão VL através dele é:

A queda de tensão no capacitor VC depende da carga (q) nele:

Onde C é a capacitância.

A segunda lei de Kirchhoff afirma que a soma algébrica das quedas de voltagem em torno de um circuito fechado é zero. Depois que a chave é fechada, tem-se:

Entretanto, a corrente está relacionada com a carga por:

Portanto,

Trata-se de uma equação diferencial ordinária linear de segunda ordem. A solução é dada por:

Na qual t = 0, q = q0 =V0C e V é voltagem fornecida pela bateria. A equação (1) descreve a variação no tempo na carga do capacitor.

Um problema de projeto típico em engenharia ( elétrica, controle, computação) poderia envolver a determinação do resistor apropriado para dissipar energia a uma taxa específica , com valores conhecidos para L e C. Para esse Problema, suponha que a carga deve ser dissipada a 1% do seu valor original (q/q0 = 0,01) em t=0,05s, com L = 5 H e C = 10^-3 F

PS: Use o método da Bissecção. O método de Newton-Raphson pode ser inconveniente em virtude do cálculo da derivada de (1) ser trabalhoso.

A variável implícita da equação é R.

Resolução:

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

main(){

    int opcao = 0 ,k =0 ;

    float x = 0, y = 0, p = 0, M = 0, Fy = 0, Fyy = 0, Fm = 0, aux =0 , aux1=0 , er = 0, e =0.;

opcao = 0;

while(opcao != 2){

printf("\n\n\t\t");

printf("************\n \n \t");

printf("MENU DE OPCOES");

printf("\n\n\t");

printf("1 - Inserir Chute para o metodo.");

printf("\n\n\t");

printf("2 - Sair");

printf("\n\n\t");

printf("Escolha Opcao: ");

scanf("%d", &opcao);

switch(opcao){

case 1:{

                    printf("\n\n\t\t");

                    printf("************\n \n \t");

                    printf( "Digite valor de A:" );

                    scanf( "%f", &x );

                    printf("\n\n\t");

                    printf( "Digite valor de B:" );

                    scanf( "%f", &y );

                    printf("\n\n\t");

                    printf( "Digite a precisao desejada:" );

                    scanf( "%f", &p );

                    printf("\n");

                    k=0;

                do{

                    M = ( x + y ) / 2;

                    Fy =  (pow(M_E,-0.005*x)*cos(sqrt(2000-0.01*pow(x,2))*(0.05)))-0.01;

                    Fm = (pow(M_E,-0.005*M)*cos(sqrt(2000-0.01*pow(M,2))*(0.05))) -0.01;

                    Fyy =  (pow(M_E,-0.005*y)*cos(sqrt(2000-0.01*pow(y,2))*(0.05)))-0.01;

                    aux = Fy*Fm ;

                    aux1 = Fyy*Fm ;

                    if ( aux < 0 ){

                        y = M;

                    }

                    else if ( aux1 < 0){

                        x = M;

                    }

                    if (x > 447 || y > 447)

                        break;

                    if (  aux > 0 && aux1 > 0 ){

                        printf("\n\n\t");

                        printf(" Entre as variaveis A e B não possuem raizes  .");

                        break ;

                    }

                    k++;

                    printf("\n\n\t");

                    printf( "iteracao = %d\n", k );

                    printf( "A = %.20f\nB = %.20f\n", x, y );

                } while( y - x >= p || Fy >= p || Fyy >= p  );

                    er = y - x ;

                    e = (y+x)/2;

                    if (er < 0)

                        er = er*-1;

                    printf("\nO erro e  = %.20f\n", er);

                    printf( "A valor de R e: %.20f\n", e );

break;

}

            case 2:{

                printf("\n\n\t");

                printf("Voce SAIU com SUCESSO");

                printf("\n\n");

break;

}

default:{

printf("\n\n\t");

printf("Opcao INVALIDA");

printf("\n\n");

}

}

}

}

Lista vinculada e ordenada em C++

#include <iostream>
#include <cstdio>
using namespace std;

/* um nó da lista unicamente ligada */
struct Node
{
    int data;
    struct Node *next;
};

/* Uma função de utilidade para inserir um nó no início da lista vinculada */
void push(struct Node** head_ref, int new_data)
{
    /* alocar o nó */
    struct Node* new_node = new Node;

    /* coloque os dados  */
    new_node->data  = new_data;

    /* vincule a lista antiga do novo nó */
    new_node->next = (*head_ref);

    /* mova a cabeça para apontar para o novo nó */
    (*head_ref)    = new_node;
}

/* Uma função de utilidade para imprimir lista vinculada */
void printList(struct Node *node)
{
    while (node != NULL)
    {
        printf("%d  ", node->data);
        node = node->next;
    }
    printf("\n");
}

//Retorna o último nó da lista
struct Node *getTail(struct Node *cur)
{
    while (cur != NULL && cur->next != NULL)
        cur = cur->next;
    return cur;
}

//Particiona a lista tomando o último elemento como o pivô
struct Node *partition(struct Node *head, struct Node *end,
                       struct Node **newHead, struct Node **newEnd)
{
    struct Node *pivot = end;
    struct Node *prev = NULL, *cur = head, *tail = pivot;

    //Durante a partição, tanto a cabeça como o final da lista podem mudar
    //que é atualizado nas variáveis newHead e newEnd
    while (cur != pivot)
    {
        if (cur->data < pivot->data)
        {
            // Primeiro nó que tem um valor menor que o pivô - torna-se
            // a nova cabeça
            if ((*newHead) == NULL)
                (*newHead) = cur;

            prev = cur;
            cur = cur->next;
        }
        else // Se o nó cur for maior do que o pivô
        {
            // Mova o nó cur para a próxima cauda e troque a cauda
            if (prev)
                prev->next = cur->next;
            struct Node *tmp = cur->next;
            cur->next = NULL;
            tail->next = cur;
            tail = cur;
            cur = tmp;
        }
    }

    // Se os dados de pivô forem o elemento mais pequeno da lista atual,
    // pivô torna-se a cabeça
    if ((*newHead) == NULL)
        (*newHead) = pivot;

    //Atualize newEnd para o último nó atual
    (*newEnd) = tail;

    //Retornar o nó pivô
    return pivot;
}


//aqui a classificação acontece sem o nó final
struct Node *quickSortRecur(struct Node *head, struct Node *end)
{
    // base condition
    if (!head || head == end)
        return head;

    Node *newHead = NULL, *newEnd = NULL;

    // Participar na lista, newHead e newEnd serão atualizados
    // pela função de partição
    struct Node *pivot = partition(head, end, &newHead, &newEnd);

    //Se o pivô é o elemento mais pequeno - não há necessidade de recorrer
    //a parte esquerda.
    if (newHead != pivot)
    {
        //Defina o nó antes do nó pivô como NULL
        struct Node *tmp = newHead;
        while (tmp->next != pivot)
            tmp = tmp->next;
        tmp->next = NULL;

        //Recorrer para a lista antes do pivô
        newHead = quickSortRecur(newHead, tmp);

        //Mude o próximo último nó da metade esquerda para girar
        tmp = getTail(newHead);
        tmp->next =  pivot;
    }

    //Recorrer para a lista após o elemento de pivô
    pivot->next = quickSortRecur(pivot->next, newEnd);

    return newHead;
}

//A principal função para quicksort. Este é um invólucro sobre recursivo
// funcão quickSortRecur()
void quickSort(struct Node **headRef)
{
    (*headRef) = quickSortRecur(*headRef, getTail(*headRef));
    return;
}

int main()
{
    struct Node *a = NULL;
    push(&a, 5);
    push(&a, 20);
    push(&a, 4);
    push(&a, 3);
    push(&a, 30);

    cout << "\nLista vinculada antes de ordenar \n";
    printList(a);

    quickSort(&a);

    cout << "\n\nLista vinculada apos a classificacao \n";
    printList(a);

    return 0;
}

Letras alfabéticas em C/C++

Imprimindo as letras alfabéticas de A até Z em C/C++

#include <stdio.h>
int main(){
char i, j=0;

for(i = 'A'; i<= 'Z'; i++){
printf("[%c %c]\n",i,i+32);
}
printf("\n\n");

for(i = 65; i<=90; i++){
printf("[%c %c]\n",i, i+32);
}
return 0;
}

Fila em C++

Objetivo: Inserir dados em uma lista e remover o ultimo elemento inserido, consultar a lista e exibir os dados da lista  (Funciona como fila).

#include <stdio.h>
#include <stdlib.h>
#include <cstdlib>
#include <iostream>
using namespace std;

typedef struct celulalista{
int informacao;
struct celulalista *proximo;
}celula;

void initlista(celula *pRecebido);
void insertlista(celula *pRecebido);
void buscalistasimples(celula *pRecebido);
void removeelementolistasimples(celula *pRecebido);
int levalor(int *valorrecebido);

int main(){
//Declaracoes
celula *pLista;
int opcao=0;

//pLista = (celula *)malloc(sizeof(struct celulalista));

pLista = new celulalista;
initlista(pLista);
for(;;)
{
cout<<"\n\t1 - Inserir : ";
cout<<"\n\t2 - Consultar : ";
cout<<"\n\t3 - Remover : ";
cout<<"\n\t4 - Sair : \n\t";
cin>>opcao;
opcao = levalor(&opcao);
switch(opcao)
{
case 1:
insertlista(pLista);
break;
case 2:
buscalistasimples(pLista);
break;
case 3:
removeelementolistasimples(pLista);
break;
case 4:
exit(0);
}
}
return 0;
}

/*
Inicializacao da lista encadeada
*/

void initlista(celula *pRecebido){
(pRecebido)->proximo = NULL;
}

/*
Funcao para insercao no inicio
*/

void insertlista(celula *pRecebido){
//Declaracoes
celula *temporario;
int valor;
//Instrucoes
cout<<"\n\tInforme um valor a ser inserido : ";
cin>>valor;
temporario = (celula * )malloc(sizeof(celula));
temporario->informacao = valor;
temporario->proximo = (pRecebido)->proximo;
(pRecebido)->proximo = temporario;
}

/*
Funcao para percorrer elementos
*/

void buscalistasimples(celula *pRecebido){
//Declaracoes
celula *temporario;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\tLista Vazia!\n";
}else{
temporario = (celula * )malloc(sizeof(celula));
temporario = (pRecebido)->proximo;
system("cls");
while(temporario!=NULL){
cout<<"\n\tValor : "<<temporario->informacao<<"\n";
temporario = temporario->proximo;
}
}
}
/*
Remove elemento da cabeca
*/

void removeelementolistasimples(celula *pRecebido){
//Declaracoes
celula *temporario;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\n\tLista Vazia!";
}else{
temporario = (pRecebido)->proximo;
(pRecebido)->proximo = temporario->proximo;
free(temporario);
}
}

int levalor(int *valorrecebido){
//Declaracoes
//Instrucoes
while((*valorrecebido > 4 )|| (*valorrecebido<1)){
cout<<"\n\tOpcao Invalida. Informe novamente : \n";
scanf("%d", &(*valorrecebido));
}
return (*valorrecebido);
}

Fatorial em C

#include <stdio.h>
#include <stdlib.h>
unsigned int FACTORIAL (int N){
int I, FACT = 1;
if(N < 0)
return 0;
for(I = 2; I<=N; I++)
FACT *= I;
return FACT;
}
int main(){
int num;
printf("Digite o valor a ser calculador: ");
scanf("%d",&num);
printf("\nFatorial de %d = %d \n\n", num, FACTORIAL(num));

return EXIT_SUCCESS;
}

Algoritmo Método da Bisseção C/C++ / Java

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <cstdlib>
using namespace std;

float funcao(float var){

return (pow(var, 3))-2*var;
}

int main(){
float a, b, aux, Erro = 0.01, iteracoes, xm, xx, Errox, Raiz;
int i= 0, k, j;
double fa, fx, fax;

    printf("\t\t\tALGORITMO DA BISSECCAO\n\n");
    printf("\t\t\tAlunos: Henrique, Dhejck");

printf("\n\n\tDigite o intervalo A: ");
scanf("%f", &a);
printf("\n\tDigite o intervalo B: ");
scanf("%f", &b);

//calculando a quantidade de iterações de acordo com a formula
iteracoes = (log10(b-a)-log10(Erro))/log10(2);
printf("\n\tNumero de Interacoes = %.1f \n\n", iteracoes);


printf("\nITERACOES: A(n) B(n)   X(m)     Erro   F(a)   F(xm)     F(a).F(xm)");
for(int i=i+1; i <= iteracoes +1; i++){
k = i+0;
xm = (a+b)/2;

Errox = b-a;

printf("\nIteracao: %d   %.4f   %.4f    %.4f    %.4f    %.2f %.2f   %.2f", i, a, b, xm, Errox, fa= funcao(a), fx= funcao(xm), fax= funcao(a) * funcao(xm));

if(funcao(a)* funcao(xm) < 0){
a = a;
b = xm;
}
else{
a = xm;
b = b;
}
}

printf("\n\n\tRAIZ = [%.4f]: apos %d Iteracoes com 4 casas decimais\n\n\n", xm, k);
printf("\n\n\Q1= %f", funcao(a));
//printf("\n\nFunc = %.5f\n\n",func(a));

system("PAUSE");
return (0);
}

EM LINGUAGEM JAVA

package trabalho.pkg2.bissecao;
import java.io.PrintStream;
import static java.lang.Math.log10;
import static java.lang.Math.pow;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
     
        double a, b, xm, Erro= 0.01, iteracoes, Errox;
        double fa, fxm;
        int i = 0, k = 0, cont = 0;
     
        System.out.println("\tALGORITMO DA BISSECÇÃO:");
        System.err.println("\tAlunos: Henrique\n");
     
        System.out.printf("Digite o intervalo A: ");
        a = input.nextDouble();
     
        System.out.printf("Digite o intervalo B: ");
        b = input.nextDouble();
     
        xm = (a+b)/2;
     
        iteracoes = (((log10(b-a))- log10(Erro)) / log10(2));
        System.out.printf("\nNúmero de iteracoes = %.1f \n",iteracoes);
     
        System.err.println("\tIterações: A(n)    B(n)      X(n)      Erro(n)    f(a)     F(xm)");
     
        if(xm == 0){
            System.out.println("Raiz = 0 ou possui mais de 1 raiz");
        }else{
            for(i= i+0; i <= iteracoes +1; i++){
                k = i+0;
                xm = (a+b)/2;
                Errox = b-a;
             
                System.out.printf("\nIterações: %d    %.2f       %.2f      %.2f      %.2f       %.2f    %.2f", i, a, b, xm, Errox, fa= funcao(a), fxm=funcao(a)*funcao(xm));
             
                if(funcao(a)* funcao(xm) < 0){
                    a = a;
                    b = xm;
                }else{
                    a = xm;
                    b = b;
                }
            }
        }
        System.err.println("Raiz = "+xm+" após "+k+" iterações:\n");
    }
    public static double funcao(double x){
        return pow(x, 3)-2*x;
    }
}