Informe o valor a ser empilhado: 7
O nó no meio da pilha é: 7
Informe o valor a ser empilhado: 4
O nó no meio da pilha é: 7
Informe o valor a ser empilhado: 2
O nó no meio da pilha é: 4
Informe o valor a ser empilhado: 9
O nó no meio da pilha é: 4
Informe o valor a ser empilhado: 5
O nó no meio da pilha é: 2

Os elementos da pilha são:
5 9 2 4 7

A pilha sem o elemento do meio:
5 9 4 7

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

// estrutura usada para representar os nós da pilha
struct No {
  int valor; // valor do nó
  struct No* proximo; // aponta para o próximo nó
  struct No* anterior; // aponta para o nó anterior
};

// estrutura que representa a pilha. Note os ponteiros para
// o nó do topo, o nó do meio e um contador de nós
struct Pilha {
  struct No* topo;
  struct No* meio;
  int contador;
};

// função usada para empilhar um novo elemento na pilha
void empilhar(struct Pilha* pilha, int valor) {
  // vamos reservar memória para um novo nó
  struct No* novo_no = (struct No*)malloc(sizeof(struct No));
  // definimos o valor do novo nó
  novo_no->valor = valor;
  // o anterior do novo nó não aponta para ninguém
  novo_no->anterior = NULL;
  // o próximo do novo nó aponta para o topo da pilha
  novo_no->proximo = pilha->topo;

  // agora atualizamos o meio da pilha baseado no número de
  // nós que temos até agora
  if (pilha->contador == 0) {
    pilha->meio = novo_no;
  }
  else if (pilha->contador % 2 == 0) {
    pilha->meio = pilha->meio->anterior;
  }

  // atualizamos o ponteiro anterior do nó no topo
  if (pilha->topo != NULL) {
    pilha->topo->anterior = novo_no;
  }

  // finalmente atualizamos o ponteiro topo e
  // incrementamos o contador
  pilha->topo = novo_no;
  pilha->contador++;
}

// função usada para desempilhar um elemento da pilha
int desempilhar(struct Pilha* pilha) {
  // vamos obter o nó que está no topo da pilha
  struct No* topo = pilha->topo;
  int valor = topo->valor;

  // ajustamos o topo da pilha para o nó seguinte
  pilha->topo = topo->proximo;

  // agora precisamos ajustar o ponteiro anterior
  if (pilha->topo != NULL) {
    pilha->topo->anterior = NULL;
  }

  // liberamos a memória do ponteiro que removemos
  free(topo);

  // atualizamos o ponteiro do meio baseado no
  // número de elementos
  if (pilha->contador % 2 == 1) {
    pilha->meio = pilha->meio->proximo;
  } 

  // diminuimos o contador
  pilha->contador--;

  // e retornamos o valor do nó removido
......

void contar_recursivamente(int n){
  // sua implementação aqui
}

0  1  2  3  4  5  6  7  8  9  10

#include <stdio.h>
#include <stdlib.h>
  
// método recursivo que conta de 0 até 10;
void contar_recursivamente(int n){
  // vamos exibir o número atual
  printf("%d  ", n);
    
  // devemos prosseguir com a recursividade?
  if(n < 10){
    // incrementa o valor de n
    n++;  
    contar_recursivamente(n); // e faz uma nova chamada recursiva
......

// uma matriz de inteiros contendo sete elementos
int valores[] = {6, 9, 12, 34, 83, 20, 17};

Ordem original:

6 9 12 34 83 20 17 

Ordem inversa:

17 20 83 34 12 9 6

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

int main(int argc, char *argv[])
{
  // uma matriz de inteiros contendo sete elementos
  int valores[] = {6, 9, 12, 34, 83, 20, 17};
  int tam_matriz = 7;
  int i;
    
  // primeiro vamos exibir os valores da matriz na ordem original
  printf("Ordem original:\n");

  for(i = 0; i < tam_matriz; i++){
......

#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
......