Lista Enlazada en C

/*escribir un programa q en una lista enlazada realice:

1.Agregar(Agregar un numero)
2.Ordenar(Ordenar la lista)
3.Insertar(Insertar un numero aleatorio en la lista en la posicion que corresponde,
debe estar ordenada con anterioridad)
4.Buscar(un elemento si está o no en la lista)
5.eliminar(un elemento de la lista(si no está q presente un mensaje))
6.Presentar(la lista enlazada)
7.salir

*/

#include
#include
#include
#define MX 1
#define randomize (srand(time(NULL)))
#define random(num) (rand()%(num))

typedef int Item;

typedef struct Elemento{
Item dato;
struct Elemento* siguiente;

}Nodo;
void InsertarNodo(Nodo** ant, Item d);

void InsertarCabezaLista(Nodo** cabeza, Item entrada);
Nodo* NuevoNodo(Item x);
int EsVacia(Nodo *cabeza);
Nodo* BuscarEnLista(Nodo* cabeza, Item dato);
void AnadePL(Nodo** L, Item e);
void InsertarEnOrden(Nodo** cabeza, Item dato);
void EliminarEnLista(Nodo** cabeza, Item dato);
void ordena(Nodo** cabeza, int n);
void presentar(Nodo** cabeza);

void main(){
Item d;
int op;
int n, i;
int num;
Nodo *cabeza;//declaracion de un puntero a una estructura
cabeza=NULL;//inicializa cabeza en lista vacia
randomize;


while(op!=7){

printf(" \n 1. AGREGAR \n 2. ORDENAR \n 3. INSERTAR UN ELEMENTO \n 4. BUSCAR \n 5. ELIMINAR \n 6. PRESENTAR \n 7. SALIR \n ");
printf("Ingrese la opcion que desea: ");
scanf("%d",&op);

switch(op){

case 1:

printf("Ingrese cuantos numeros desea almacenar: ");
scanf("%d",&n);
for(i=1; i<=n; i++){
d = random(30);
InsertarNodo(&cabeza, d);
}
printf("Elementos anadidos aleatoriamente ");
break;

case 2:
if(EsVacia(cabeza)!=NULL){
printf("La lista esta vacia");
}else{
ordena(&cabeza,n);
printf("Ordenado correctamente \n");
presentar(&cabeza);
}
break;


case 3:

if(EsVacia(cabeza)!=NULL){
printf("La lista esta vacia \n");
}else{
ordena(&cabeza,n);
printf("Ingrese el numero a insertar:");
scanf("%d", &num );
InsertarEnOrden(&cabeza, num);
printf("Insertado correctamente");

}

break;

case 4:


if(EsVacia(cabeza)!=NULL){
printf("La lista esta vacia \n");
}else{
printf("Ingrese un numero a buscar en la lista: ");
scanf("%d", &num);
if(BuscarEnLista(cabeza,num)!=NULL){
printf("Elemento encontrado");
}else{
printf("Elemento no encontrado");
}
}

break;


case 5:

if(EsVacia(cabeza)!=NULL){
printf("La lista esta vacia \n");
}else{
printf("Ingrese un numero que desee eliminar:");
scanf("%d", &num);
EliminarEnLista(&cabeza, num);
presentar(&cabeza);
}
break;

case 6:
presentar(&cabeza);
break;
}
}
}
Nodo* NuevoNodo(Item x){

Nodo *a;
a=(Nodo*)malloc(sizeof(Nodo));
a->dato = x;
a->siguiente=NULL;
return a;

}
void InsertarNodo(Nodo** ant, Item d){
Nodo *a;
a= NuevoNodo(d);
a->siguiente = *ant;
*ant = a;
}
void presentar(Nodo** cabeza){
Nodo *ptr;
int k;
for(k=0,ptr=*cabeza;ptr;){//si ptr es un puntero hast q ptr sea null
printf("%d ",ptr->dato);
k++;
ptr= ptr->siguiente;
printf("\n");
}
}

int EsVacia(Nodo *cabeza){
return(cabeza==NULL);
}



Nodo* BuscarEnLista(Nodo* cabeza, Item dato){
Nodo *Ptr;
for(Ptr= cabeza; Ptr != NULL; Ptr->siguiente){
if(Ptr->dato == dato){
return Ptr;
}
return NULL;
}

}

void InsertarEnOrden(Nodo** cabeza, Item dato){
Nodo *nuevo, *ant, *pos;
nuevo=NuevoNodo(dato);
if(*cabeza == NULL)
*cabeza =nuevo;
else
if(dato<=(*cabeza)->dato){
nuevo->siguiente=*cabeza;
*cabeza=nuevo;
}
else{
ant=pos=*cabeza;
while((dato>pos->dato) &&(pos->siguiente != NULL)){
ant=pos;
pos=pos->siguiente;
}
if(dato>pos->dato)
ant= pos;
nuevo->siguiente= ant->siguiente;
ant->siguiente=nuevo;
}
}
void EliminarEnLista(Nodo** cabeza, Item dato){

Nodo *ant, *pos;

int encontrado=0;
ant =NULL;
pos= *cabeza;

while((!encontrado)&&(pos != NULL)){
encontrado=(dato<=(pos->dato));
if(!encontrado){
ant=pos;
pos= pos->siguiente;
}
}
if(encontrado)
encontrado=((pos->dato)== dato);
if(encontrado){
if(ant == NULL)
*cabeza = pos->siguiente;
else
ant->siguiente=pos->siguiente;
free(pos);
}
}
void ordena(Nodo** cabeza, int n){
int i, j;
Nodo *aux, *aux1, *anterior;
for(i=1; i j=1;
aux=*cabeza;
anterior =NULL;
while(j<= (n-i)){
aux1=aux->siguiente;
if(aux->dato > aux1->dato){
aux->siguiente=aux1->siguiente;
aux1->siguiente= aux;
if(anterior == NULL){
*cabeza=aux1;
anterior= *cabeza;
}
else{
anterior->siguiente=aux1;
anterior=aux1;
}
aux= anterior->siguiente;
}
else{
anterior=aux;
aux=aux1;
}
j++;
}
}
}

Listas Enlazadas en C

#include
#include
typedef int Item;
struct unnodo{
Item dato;
struct unnodo *adelante;};
typedef struct unnodo Nodo;
int main(){
Nodo* p = NULL;
Nodo* p1 = NULL;
p = (Nodo*)malloc(sizeof(Nodo));
p1 = (Nodo*)malloc(sizeof(Nodo));
p->dato = 50;
p1->dato = 150;
(*p).adelante = NULL; p->adelante = NULL;
p1->adelante = NULL;
printf("%d\n",(*p).dato); printf("%d\n",p1->dato);
p->adelante = p1;
return 0;
}

Matriz con Datos Aleatorios en C

#include
#include
# define N 10
void tamano(int* a,int* b);
void llenar(int m[][N],int a,int b);
void presentar(int m[][N],int a,int b);
int main(){
int m[N][N];
int a,b;
srand(time(NULL));
tamano(&a,&b);
llenar(m,a,b);
presentar(m,a,b);
}
void tamano(int* a,int* b){
printf("Ingrese el numero de filas: ");
scanf("%d",a);
printf("Ingrese el numero de columnas: ");
scanf("%d", b);
}
void llenar(int m[][N],int a,int b){
int i,j;
for(i=1; i<=a;i++){
for(j=1; j<=b;j++){
m[i][j]=rand()%100;
}
}
}
void presentar(int m[][N],int a,int b){
int i,j;
for(i=1; i<=a;i++){
for(j=1; j<=b;j++){
printf("%3d",m[i][j]);
}
printf("\n");
}
}

Puntero a puntero en C

#include
main() {
int a = 100;
int* ptr_a;
int** ptr_ptr_a;
ptr_a = &a;
*ptr_a = 200;
printf("\n\n Valor de a: %d", a);
ptr_ptr_a = &ptr_a;
*(*ptr_ptr_a) = 300;
printf ("\n\n Valor de a: %d", a);
printf ("\n\n");
}

Convertir de Decimal a Varios Criterios en C

//Programa en C que convierte de decimal a varios criterios con recursividad

#include

#define DEBUG 0
int DaB(int);

int main(void)
{
int numero = 155;
int a,R;

printf("\nIngrese el numero que desea convertir: ");
scanf("%d",&numero);

if(DEBUG == 0) {
printf("\n Binario: ");
DaB(numero);
printf("\n Octal:");
DaO(numero);
printf("\n Hexagesimal:");
DaH(numero);


}
getchar();
getchar();
return 0;
}


int DaB(int numero){
int a,R;
R = numero % 2;
a = numero / 2;
if(DEBUG != 0){
printf("a = %i\n",a);

}
if (a > 0)
DaB(a);
if(DEBUG != 0){
printf("R = %d\n",R);

}
else
printf("%d",R);
return 0;
}



int DaO(int numero){
int a,R;
R = numero % 8;
a = numero / 8;
if(DEBUG != 0){
printf("a = %i\n",a);

}
if (a > 0)
DaO(a);
if(DEBUG != 0){
printf("R = %d\n",R);

}
else
printf("%d",R);
return 0;
}


int DaH(int numero){
int a,R;
R = numero % 16;
a = numero / 16;
if(DEBUG != 0){
printf("a = %i\n",a);

}
if (a > 0)
DaH(a);
if(DEBUG != 0){
printf("R = %d\n",R);

}
else
printf("%d",R);
return 0;
}

Metodos de Ordenacion en C

//Programa en C (Metodos de Ordenacion)

#include
#include
#include
# define N 10

void tamano(int* a);
void llenar(int m[],int a);
void presentar(int m[],int a);
void burbuja(int m[], int a);
void shell(int m[N], int a);
void QuikShort(int m[], int izq, int der);
void insercionbinaria(int m[], int a);

int main() {
int m[N];
int a, t=0,izq=1;
srand(time(NULL));
tamano(&a);
llenar(m,a);
presentar(m,a);

printf("Ingrese el metodo de ordenacion por: \n 1. Burbuja \n 2. Shell \n 3. Quick Short \n 4. Insercion Binaria \n");
scanf("%d",&t);


if (t==1){
printf(" Vector Ordenado por metodo Burbuja: \n");
burbuja(m,a);
presentar(m,a);
}

if (t==2){
printf(" Vector Ordenado por Shell: \n");
shell(m,a);
presentar(m,a);
}

if (t==3){
printf(" Vector Ordenado por Quick Short: \n");
QuikShort(m,izq,a);
presentar(m,a);
}

if (t==4){

printf(" Vector Ordenado por Insercion Binaria: \n");
insercionbinaria(m,a);
presentar(m,a);
}
if (t<1|| t>4){
printf("Seleccione correctamente el metodo de ordenacion \n");
}
}


void tamano(int* a){
printf("Ingrese la longitud del vector: ");
scanf("%d",a);

}

void llenar(int m[],int a){
int i;
for(i=1; i<=a;i++){
m[i]=rand()%10;
}
}

void presentar(int m[],int a){
int i;
for(i=1; i<=a;i++){
printf("%3d",m[i]);
printf("\n");

}
}

//Metodos de Ordenacion

void burbuja(int m[], int a){
int i,j;
int aux;
for(i=1; i<=a-1; i++){
for(j=1; j<=a-1; j++){
if(m[j]>m[j+1]){
aux=m[j];
m[j]=m[j+1];
m[j+1]=aux;
}
}
}
}


void shell(int m[N], int a){
int salto, k, j, ord;
int aux;
salto=a;
while(salto>1){
salto=salto/2;
do{
ord=1;
for(j=1; j<=a-1-salto; j++){
k=j+salto;
if(m[j]>m[k]){
aux=m[j];
m[j]=m[k];
m[k]=aux;
ord=0;
}
}
}while(!ord);

}
}


void QuikShort(int m[], int izq, int der){
int i=izq,j=der;
int x,w;
x=m[(izq+der)/2];
do{
while(m[i] i++;
while(x j--;
if(i<=j){
w=m[i];
m[i]=m[j];
m[j]=w;
i++;
j--;
}
}while(i<=j);
if(izq if(i
};


void insercionbinaria(int m[], int a){

int i,j,p,u,c;
int aux;
for(i=1; i<=a; i++ ){
aux=m[i];
p=0;
u=i-1;
while(p<=u){
c=(p+u)/2;
if(m[c]>aux)
u=c-1;
else
p=c+1;
}
for(j=i-1; j>=p; j--)
m[j+1]=m[j];
m[p]=aux;
}
}