PROYECTOS ALGORITMIA "METODOS DE ORDENACIÓN"

#include<stdio.h>

#include<windows.h>

#include<conio.h>

#include <time.h>

#include <limits.h>

#include <string.h>

#include <stdlib.h>

#define INFINITY 9999

#define MAX 10

#define MAX2 100

#define INICIAL 1

#define ESPERANDO 2

#define VISITADO 3

//Matriz de adyacencia general

int G[MAX][MAX];

//Cantidad de nodos

int n;

// Funciones 'Dijkstra'

void entradaDatosDijkstra();

void dijkstra(int G[MAX][MAX],int n,int startnode, char Nombres[MAX]);

int indiceNodo(char Nombres[MAX],char c, int n);

// Funciones, estructuras y variables 'Kruskal'

void entradaDatosKruskal();

typedef struct edge

{

int u,v,w;

}edge;

typedef struct edgelist

{

edge data[MAX];

int n;

}edgelist;

edgelist elist;

edgelist spanlist;

void kruskal();

int find(int belongs[],int vertexno);

void union1(int belongs[],int c1,int c2);

void sort();

void printSubGrafo(char Nombres[MAX]);

//Variables y funciones 'Prim'

int spanning[MAX][MAX];

int prims();

void entradaDatosPrim();

// Variables y funcion ´Primero en Profundidad´ (DFS)

void entradaDatosDFS();

void DFS(int, int, char Nombres[MAX]);

int visited[10];

// Funciones 'Primero en anchura' (BFS)

int adj[MAX2][MAX2];

int state[MAX2];

void create_graph();

void BF_Traversal();

void BFS(int v);

int queue[MAX2], front = -1,rear = -1;

void insert_queue(int vertex);

int delete_queue();

int isEmpty_queue();

void entradaDatosBFS();

//Bellman-Ford

struct Edge

{

int source, destination, weight;

};

struct Graph

{

int V, E;

struct Edge* edge;

};

struct Graph* createGraph(int V, int E)

{

struct Graph* graph = (struct Graph*) malloc( sizeof(struct Graph));

graph->V = V;

graph->E = E;

graph->edge = (struct Edge*) malloc( graph->E * sizeof( struct Edge ) );

return graph;

}

void FinalSolution(int dist[], int n);

void BellmanFord(struct Graph* graph, int source);

void entradaDatosBellman();

/*FUNCION QUE AYUDA A CONTROLAR EL PUNTERO*/

void gotoxy(int x, int y){

HANDLE hCon;

COORD dwPos;

dwPos.X = x;

dwPos.Y = y;

hCon = GetStdHandle(STD_OUTPUT_HANDLE);

SetConsoleCursorPosition(hCon,dwPos);

}

/*FUNCION ESPECIFICA DEL MARCO GRAFICO*/

marco (int x1,int y1,int x2,int y2,int c1,int c2){

for(int i=x1+1;i<x2; i++){

gotoxy(i,y1);printf("%c",c1);

gotoxy(i,y2);printf("%c",c1);

}

for(int i=y1+1;i<y2;i++){

gotoxy(x1,i);printf("%c",c2);

gotoxy(x2,i);printf("%c",c2);

}

gotoxy(x1,y1);printf("%c",201);

gotoxy(x2,y1);printf("%c",187);

gotoxy(x1,y2);printf("%c",200);

gotoxy(x2,y2);printf("%c",188);

}

/*MENU EN DONDE DA OPCION DE RECURSIVO E ITERATIVO*/

int menuinterno(){

int opc2;

do{

system("cls");

marco(28,5,58,17,205,186);

gotoxy(30,9);printf("1. Recursivo\n");

gotoxy(30,10);printf("2. Iterativo\n");

gotoxy(30,11);printf("3. Regresar al menu anterior\n");

gotoxy(30,12);printf("Elije una opcion: ");

scanf("%d",&opc2);

switch(opc2){

case 1:

return 1;

break;

case 2:

return 2;

break;

case 3:

gotoxy(30,14);printf("Regresando al menu anterior");

Sleep(1000);

break;

default:

gotoxy(30,14);printf("Opcion no valida");

Sleep(1000);

break;

}

}while(opc2 !=3);

}

/*ALGORITMO FACTORIAL*/

unsigned long long factorial(int x){

if(x == 0)

return 1;

else

return (x*factorial(x-1));

}

/*ALGORITMO FIBONACCI*/

int fibonacci(int x){

if(x == 1)

return 1;

if(x == 0)

return 0;

return fibonacci(x-2) + fibonacci(x-1);

}

/*SUMA DE DIGITOS*/

digitos(int x,int y){

if(x==0)

return y;

y = y + (x%10);

x = x/10;

digitos(x,y);

}

/*DADOS DOS NUMEROS ENCONTRAR EL MAXIMO COMUN DIVISOR*/

mcd(int x,int y){

if(y==0)

return x;

else

return mcd(y,x%y);

}

/*FUNCION QUE IMPRIME GRFAICA EN PANTALLA*/

void grafica(int v[10]){

for(int i=29;i<70;i++){

gotoxy(i,23);printf("%c",205);

}

for(int i=3;i<23;i++){

gotoxy(28,i);printf("%c",186);

}

gotoxy(28,23);printf("%c",200);

for(int i=1;i<=10;i++){

gotoxy(i*3+26,24);printf("|%-2d|",v[i]);

for(int j=0;j<v[i];j++){

gotoxy(i*3+27,22-j);printf("%c%c",219,219);

}

}

}

/*ALGORITMO QUICK*/

void partition(int v[],int izq,int der){

int i,j,key,piv;

i = izq;

j = der;

piv=v[(i+j)/2];

do{

while(v[i]<piv && i<der)

i++;

while(piv<v[j] && j>izq)j--;

if(i <=j){

key= v[i];

v[i]=v[j];

system("cls");

grafica(v);

Sleep(2000);

v[j]=key;

system("cls");

grafica(v);

Sleep(2000);

i++;

j--;

...