Pila Auto

#include <iostream>
#include <conio.h>
#include <stdio.h>
using namespace std;
void alta();
void muestra();
void muestra1();
void muestra0();
void separa();
void invertir();
void muestra_inv();

struct pila_auto
{
  char placa[10];
  int modelo;
  pila_auto *sig;
}*cab=NULL, *ptr, *cab1=NULL, *ptr1, *cab0=NULL, *ptr0;

int main()
{
  int opcion;

  while(1)
  {
  system("cls");
  cout << "MENU" << endl << endl << "1. alta" << endl << "2. muestra" << endl << "3. muestra1" << endl << "4. muestra0" << endl << "5. separa" << endl << "6. salir" << endl << endl << "opcion: ";
  cin >> opcion;

    switch(opcion)
    {
      case 1:
        alta();
        break;
      case 2:
        muestra();
        break;
      case 3:
        muestra1();
        break;
      case 4:
        muestra0();
        break;
      case 5:
        separa();
        break;
      case 6:
        return 666;
        break;
      default:
        cout << endl << "opcion incorrecta" << endl;
        break;
    }
  }
}
void alta()
{
  ptr = new pila_auto;
  cout << endl << "proporciona placa: ";
  fflush(stdin);
  gets(ptr -> placa);
  cout << endl << "modelo: ";
  cin >> ptr -> modelo;
  ptr -> sig=cab;
  cab=ptr;
}
void muestra()
{
  ptr = cab;
  cout << endl;
  while(ptr!=NULL)
  {
    cout << endl << ptr -> placa << endl;
    cout << ptr -> modelo << endl;
    ptr = ptr -> sig;
  }
  getche();
}
void muestra1()
{
  ptr = cab1;
  cout << endl;
  while(ptr!=NULL)
  {
    cout << endl << ptr -> placa << endl;
    cout << ptr -> modelo << endl;
    ptr = ptr -> sig;
  }
  getche();
}
void muestra0()
{
  ptr = cab0;
  cout << endl;
  while(ptr!=NULL)
  {
    cout << endl << ptr -> placa << endl;
    cout << ptr -> modelo << endl;
    ptr = ptr -> sig;
  }
  getche();
}
void separa()
{
  ptr = cab;
  while(ptr!=NULL)
  {
    if(ptr -> modelo < 2000)
    {
      ptr1=new pila_auto;
      strcpy(ptr1 -> placa, ptr -> placa);
      ptr1 -> modelo = ptr -> modelo;
      ptr1 -> sig=cab1;
      cab1 = ptr1;
    }
    else
    {
      ptr0=new pila_auto;
      strcpy(ptr0 -> placa, ptr -> placa);
      ptr0 -> modelo = ptr -> modelo;
      ptr0 -> sig=cab0;
      cab0=ptr0;
    }
    ptr=ptr -> sig;
  }
}
/*void invertir()
{
  ptr = cab;
  while(ptr != NULL)
  {
    ptr2 = new pila;
    ptr2 -> num = ptr -> num;
    ptr -> sig = cab2;
    cab2 = ptr2;
    ptr = ptr -> sig;
  }

}
void muestra_inv()
{
  ptr = cab2;
  cout << endl;
  while(ptr!=NULL)
  {
    cout << ptr -> num << endl;
    ptr = ptr -> sig;
  }
  getche();
}
*/

Pila Basica

#include <iostream>
#include <conio.h>
#include <stdio.h>
using namespace std;
void alta();
void muestra();
void borrar();
void invertir();
void muestra_inv();
struct pila
{
  int num;
  pila *sig;
}*cab=NULL, *ptr, *cab2=NULL;

int main()
{ 
  int opcion;
 
  while(1)
  {
  system("cls");
  cout << "MENU" << endl << endl << "1. alta" << endl << "2. muestra" << endl << "3. borrar" << endl << "4. invertir" << endl << "5. mostrar pila invertida" << endl << "6. salir" << endl << endl << "opcion: ";
  cin >> opcion;
 
    switch(opcion)
    {
      case 1:
        alta();
        break;
      case 2:
        muestra();
        break;
      case 3:
        borrar();
        break;
      case 4:
        invertir();
        break;
      case 5:
        muestra_inv();
        break;
      case 6:
        return 666;
        break;
      default:
        cout << endl << "opcion incorrecta" << endl;
        break;
    }
  }
}
void alta()
{
  ptr = new pila;
  cout << endl << "dato: ";
  cin >> ptr -> num;
  if(cab==NULL)
  {
    ptr->sig=cab;
    cab=ptr;
  }
  else
  {
    ptr->sig=cab;
    cab=ptr;
  }
  getche();
}
void muestra()
{
  ptr = cab;
  cout << endl;
  while(ptr!=NULL)
  {
    cout << ptr -> num << endl;
    ptr = ptr -> sig;
  }
  getche();
}
void borrar()
{
  ptr = cab;
  cab = ptr -> sig;
  delete(ptr);
  getche();
}
void invertir()
{
  ptr = cab;
  cab = ptr -> sig;
  ptr -> sig=cab2;
  cab2 = ptr;
  getche();
}
void muestra_inv()
{
  ptr = cab2;
  cout << endl;
  while(ptr!=NULL)
  {
    cout << ptr -> num << endl;
    ptr = ptr -> sig;
  }
  getche();
}

Programa

Pida al usuario qué ingrese un número, lo descomponga en sus dígitos, luego nos digo cuantos dígitos tenia y cuanto es la suma de ellos.

#
#

Estructura de Datos

En un hospital es necesario el almacenamiento de una estructura que contenga el nombre del paciente, el nombre del doctor y el consultorio de un grupo de a lo más 20 miembros. Una vez almacenados los datos estos se ordenan por consultorio. Los usuarios obtienen información tantas veces como deseen.
La opción que elija debe ofrecer mostrar la lista de los pacientes por consultorio y mostrar los datos de un paciente en específico.



int a1, a2, *p1, *p2;
a1=125;
p1=&a1;
a2=134;
p1=&a2;
p2=p1;
a2=*p2;
¿Cuánto valen a1 y a2?


Suponga que K es un arreglo de enteros con los siguientes datos:
25 12 52 18
¿Cuál será el contenido de K después de ejecutar el código siguiente?
for (i=0; i<4; i++)
K[i]=K[i+1];
if ((K[i]%2)==0)
K[i]=5;


4Suponga que A es un arreglo de enteros de tamaño 6, escriba el contenido de a después de ejecutar el código.
for (i=0, j=5; i<6, j!=0; i++,j--)
A[i]=A[j-1];
for (i=0; i<6; i++) printf (“%d, A[i]\n”);


Si X es una variable apuntador, &X representa?
La dirección

Un apuntador o puntero es una variable que almacena
Direcciones de memoria

Un puntero representa la dirección de memoria del objeto al que apunta, mas no su
Valor o contenido

Cuando no se están usando los punteros deben tomar el valor
Null

La constante null está definida en
stdio.h

El número de índices no determina la dimensión del vector
Falso

En C no se permiten operaciones que impliquen vectores completos
True

*(x+1) representa la dirección del elemento n del vector equis
Falso

Todas las cadenas de caracteres en c finalizan con /0 ?
True

Los arreglos son un conjunto de valores todos de un mismo tipo a los que se les da un nombre común y se les distingue por su índice
True

El nombre de un vector o de un arreglo es un apuntador al primer elemento del mismo
True

Una lista no puede almacenar un número variante de elementos durante su ejecución
True

Una cadena de caracteres es un vector o un arreglo en el que cada elemento almacena un carácter
True

&x[i] representa el contenido del elemento n del arreglo
Falso, representa dirección