VARIABLES DECLARADAS ANTES DE SU USO

#INCLUDE Main(){ printf (hola mundo);}%d entero%f real%6,2fLoops While (expresin ){Orden;} For (exp1;exp2;exp3){Orden}

#include Int power(int a,int base);Main (){Int x=power(int a;int b);Printf (la wa %d , x);Return 0Sino retorno nada se return cero}Int x=10Int power (int a , int base){Int i;Int P=1; For (i=1;i0&&s[i]= valor del coso

Void no retorna pnada Void swap (int *px , int *py){Int temp;Temp=*px;*py=*px;*px=temp;}Int *PChar a[]*pa=a[0]

Punteros *(p+i) =a[i]

Int strlen(*p,a[]){Int n;For(n=0;*s!=/0;s=s+1)N=n+1;Return n;} ESTRUC TURASEj Struct point{Int x;Int y ;} Struct rect{Struct point pt1;Struct point pt2;}

Puntero a estrucutura ejemplo:Struct point { int x;Int y;}*p=point*px*py ..

Listas Struct nodo{Int data;Struct node*next;}nodo

Lista3 {Struct nodo *one=null;Struct nodo *two=null;Struct nodo *three=null;One = malloc(sizeof(struct nodo));Two=malloc(sizeof(struct nodo));Three =malloc(sizeof(struct nodo);Onedata=n1One next=twoTwo data=n2Two next=threeThree data=n3Three next=nullReturn one}

Int lenght(struct nodo*lista){Int count=0;Struct nodo *now=lista;While (*now!=null){now=nownext;Count=count+1;}}

Int print(struct node *lista ){Main (){Struct node *now=lista;While (now!=null){Printf (%d nowdata);Now=nownext;}}Struct node *newnode{Newnode=mallloc(sizeof(struct node))Newnode data=coso

Newnodenext=oneONE =newnode;}

PUSH (STRUCT NODE **HEADREF,INT DATA){NEWNODE DATA=DATANewnode next=head*Headref=newnode}

Int Pop(struct nodo**headreff){Struct nodo head;Int save ;Head=*headrefAssert( head==null);Result=headdata;*head ref=headnext;Free(head);Return result}

Lista doblemente enlazada

Typedef struct nodo {Int dato;Struct nodo *prev;Struct nodo *next;}

Push (nodo **head, int dato){Nodo *newnode=malloc(sizeof(nodo));Newnodedata =datoNewnode*next=*headNewnode *prev=null*head=newnode}int Pop{nodo **headref){Struct nodo temp=*headref;int resultIf (tempnext!=null)*headref =tempnextResult=tempdataFree (temp)*headrefprev=null}Return (result)Else{*headref==nullResult=tempdataReturn (result)Busca o hace el pop para una lista enlazada doble

StackTypedef struct stack{Int dato;Int tems[maxsize];}stack;

Void push(stack *ps,int x){If (pssize==stacksize){Fputs(error :stacks overflow \n,stderr);Abort();}Else{Psitems[pssize++]=X}}

Int pop (stack *ps){If (pssctacks==0){Fputs (error:stacks underflows , stderr);Abort()}elseReturns psitems[--pssize];}

Stack con lista simplemente enlazadaTypedef struct stack{Int data;Struct moldestack *next;}stack

Void push(stack **headref, int algo){ stack *nodo=malloc(sizeof(stack));If (node==null){Fputs (error:no space avaible for nodo, stderr);Abort()}else{Node data=algo;Nodenext=empty(*head)?null:*head;*head=node}}

Pop(stack **head){Int result;If (empty(head)){Fputs(error : stacks is underflows,stderr);Abort();}else{Stack *top =*headResult= *headdato*head=*topnextFree (top)}}

Arboles binarios de bsquedas Typedef struct moldenodo{Int dato;Struct moldenodo *left;Structmoldenodo *right;}nodo;

Lookup(nodo *node , int target){If (nodo==null);Return (nodo!=null);}else{If ( target=nodo data){Return(true);}else{If (target>nododata){Return (lookup(nodeleft,target);}else{ Return (lookup(noderight,target));}}}

Typedef struct nodo{Int clave;Struct nodo *left;Struct nodo *right;}nodo;

Nodo *creanodo(int dato){ nodo *pn=malloc(sizeof(nodo))If (pn==null){Exit(1)}else{pn clave=dato;pn right=null;pn left=null;}Return (*pn);}

Void recorraenorden(nodo *pn){If (pn==null)Recorraenorden(nodo *left);Printf (%d \n , pn clave);Recorraenorden (nodo *right);}

Void inorder(nodo *p ,int nivel){If (p!=null){inorder(nodo *left , int nivel++);Printf ( %d %d \n , pclave ,nivel);Inorder (nodo *right,int nivel++);}

Nodo buscariterativo(int clave,nodo *p){While( p!=null){If (pnkey==clave) {return pn;}Else{if (pnkey>clave;){pnright;}else{pnleft;}return pn}}

Nodo buscarecursiva(nodo *pn ,int valor)If pnkey==nullReturn falseElse{{ if (pnkey==valor) {return pn;}else{ if (pnkey>valor){return(buscarecursiva(nodo pnright, int valor);}else{return(buscarecursiva(nodo pnleft,int valor)}}}}

Int buscarminimo(nodo *pa){If (pa==nul return (null))If (paleft!=null){Buscarminimo(paleft);Return pa;}

Nodo insertarnodo(nodo *pn,int valor){If (pn==null)Return crearnodo(data);}else{if (pnkey==valor) {return (pn)}else{if (pakey