Exibição errada do SJF no Gráfico de Guntts

[Ariel Rodrigo Campos]

Boa Tarde. Preciso de ajuda pra esse código que mostra o tempo de exibição de processos. Porem, ele mostra o Gráfico de um jeito errado. Ao invés dele mostrar o gráfico assim:Gráfico de Gantt:

------------------------
1: ---XXX
2: -XX
3: X
------------------------
Ele me mostra assim:
Gráfico de Gantt:
------------------------
3: X
2: -XX
1: ---XXX
------------------------

Quem puder me ajudar eu agradeço.

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

typedef struct {
    char nome[20];
    int tempo_execucao;
    int tempo_espera_inicial;
    int tempo_processamento;
    int tempo_espera_final;
} Processo;

void fcfs(Processo* processos, int n) {
    int tempo_chegada = 0;
    int tempo_total = 0;
    printf("Gráfico de Gantt:\n");
    printf("------------------------\n");
    for (int i = 0; i < n; i++) {
        printf("%s: ", processos[i].nome);
        for (int j = 0; j < tempo_chegada; j++)
            printf("-");
        for (int j = 0; j < processos[i].tempo_execucao; j++)
            printf("X");
        printf("\n");
        tempo_chegada += processos[i].tempo_execucao;
        processos[i].tempo_espera_inicial = tempo_chegada - processos[i].tempo_execucao;
        processos[i].tempo_espera_final = tempo_total - processos[i].tempo_execucao;
        tempo_total += processos[i].tempo_execucao;
        processos[i].tempo_processamento = processos[i].tempo_execucao;
    }

    printf("\nDados adicionais:\n");
    printf("Tempo de espera para iniciar o processo:\n");
    for (int i = 0; i < n; i++) {
        printf(" %s)", processos[i].nome);
        printf("%d -", processos[i].tempo_espera_inicial);}
    printf("\nTempo de processamento do processo:\n");
    for (int q = 0; q < n; q++){
      printf(" %s)", processos[q].nome);
      printf("%d -", processos[q].tempo_processamento);
    }
    printf("\nTempo de espera para finalizar o processo:\n");
  for (int e = 0; e < n; e++){
      printf(" %s)", processos[e].nome);
      printf("%d -", 0);
    }
    printf("\n");
  
    double tempo_medio_espera_inicial = 0.0;
    double tempo_medio_espera_final = 0.0;
    for (int i = 0; i < n; i++) {
        tempo_medio_espera_inicial += processos[i].tempo_espera_inicial;
        tempo_medio_espera_final += processos[i].tempo_espera_final;
    }
    tempo_medio_espera_inicial /= n;
    tempo_medio_espera_final /= n;

    printf("Tempo médio de espera para iniciar cada processo: %.2lf\n", tempo_medio_espera_inicial);
    printf("Tempo total de processador: %d\n", tempo_total);
}

void sjf(Processo* processos, int n) {
    // Ordena os processos pelo tempo de execução (SJF)
for (int i = 0; i < n - 1; i++) {
    int menor_tempo = i;  // Índice do processo com menor tempo de execução

    for (int j = i + 1; j < n; j++) {
        if (processos[j].tempo_execucao < processos[menor_tempo].tempo_execucao) {
            menor_tempo = j;
        }
    }

    // Troca os elementos somente no final da iteração
    Processo temp = processos[i];
    processos[i] = processos[menor_tempo];
    processos[menor_tempo] = temp;
}

    int tempo_chegada = 0;
    int tempo_total = 0;
    printf("Gráfico de Gantt:\n");
    printf("------------------------\n");
    for (int i = 0; i < n; i++) {
        printf("%s: ", processos[i].nome);
        for (int j = 0; j < tempo_chegada; j++)
            printf("-");
        for (int j = 0; j < processos[i].tempo_execucao; j++)
            printf("X");
        printf("\n");
        tempo_chegada += processos[i].tempo_execucao;
        processos[i].tempo_espera_inicial = tempo_chegada - processos[i].tempo_execucao;
        processos[i].tempo_espera_final = tempo_total - processos[i].tempo_execucao;
        tempo_total += processos[i].tempo_execucao;
        processos[i].tempo_processamento = processos[i].tempo_execucao;
    }

    printf("\nDados adicionais:\n");
    printf("Tempo de espera para iniciar o processo:\n");
    for (int i = 0; i < n; i++) {
        printf(" %s)", processos[i].nome);
        printf("%d -", processos[i].tempo_espera_inicial);}
    printf("\nTempo de processamento do processo:\n");
    for (int q = 0; q < n; q++){
      printf(" %s)", processos[q].nome);
      printf("%d -", processos[q].tempo_processamento);
    }
    printf("\nTempo de espera para finalizar o processo:\n");
  for (int e = 0; e < n; e++){
      printf(" %s)", processos[e].nome);
      printf("%d -", 0);
    }
    printf("\n");
  

    double tempo_medio_espera_inicial = 0.0;
    double tempo_medio_espera_final = 0.0;
    for (int i = 0; i < n; i++) {
        tempo_medio_espera_inicial += processos[i].tempo_espera_inicial;
        tempo_medio_espera_final += processos[i].tempo_espera_final;
    }
    tempo_medio_espera_inicial /= n;
    tempo_medio_espera_final /= n;

    printf("Tempo médio de espera para iniciar cada processo: %.2lf\n", tempo_medio_espera_inicial);
    printf("Tempo total de processador: %d\n", tempo_total);
}

void circular(Processo* processos, int n, int quantum) {
    int* temp_restante = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++)
        temp_restante[i] = processos[i].tempo_execucao;

    int tempo_chegada = 0;
    int tempo_total = 0;

    // Determinar o comprimento máximo do nome dos processos
    int max_length = 0;
    for (int i = 0; i < n; i++) {
        int length = strlen(processos[i].nome);
        if (length > max_length)
            max_length = length;
    }

    printf("Gráfico de Gantt:\n");
    printf("------------------------\n");
    while (1) {
        int finalizados = 1;
        for (int i = 0; i < n; i++) {
            if (temp_restante[i] > 0) {
                finalizados = 0;
                if (temp_restante[i] > quantum) {
                    printf("%-*s: ", max_length, processos[i].nome);

                    // Adicionar espaços em branco para alinhar o gráfico de Gantt
                    for (int j = 0; j < tempo_chegada; j++)
                        printf("-");
                    for (int j = 0; j < quantum; j++)
                        printf("X");
                    printf("\n");

                    tempo_chegada += quantum;
                    temp_restante[i] -= quantum;
                    processos[i].tempo_processamento += quantum;
                } else {
                    printf("%-*s: ", max_length, processos[i].nome);

                    // Adicionar espaços em branco para alinhar o gráfico de Gantt
                    for (int j = 0; j < tempo_chegada; j++)
                        printf("-");
                    for (int j = 0; j < temp_restante[i]; j++)
                        printf("X");
                    printf("\n");

                    tempo_chegada += temp_restante[i];
                    processos[i].tempo_processamento += temp_restante[i];
                    temp_restante[i] = 0;
                }
            }
        }
        if (finalizados)
            break;
    }

    tempo_total = tempo_chegada;

    printf("\nDados adicionais:\n");
    for (int i = 0; i < n; i++) {
        processos[i].tempo_espera_inicial = processos[i].tempo_espera_inicial - processos[i].tempo_processamento;
        processos[i].tempo_espera_final = tempo_chegada - processos[i].tempo_processamento;
        printf("Tempo de espera para iniciar o processo %-*s: %d\n", max_length, processos[i].nome, processos[i].tempo_espera_inicial);
        printf("Tempo de processamento do processo %-*s: %d\n", max_length, processos[i].nome, processos[i].tempo_processamento);
        printf("Tempo de espera para finalizar o processo %-*s: %d\n", max_length, processos[i].nome, processos[i].tempo_espera_final);
    }

    double tempo_medio_espera_inicial = 0.0;
    double tempo_medio_espera_final = 0.0;
    for (int i = 0; i < n; i++) {
        tempo_medio_espera_inicial += processos[i].tempo_espera_inicial;
        tempo_medio_espera_final += processos[i].tempo_espera_final;
    }
    tempo_medio_espera_inicial /= n;
    tempo_medio_espera_final /= n;

    printf("Tempo médio de espera para iniciar cada processo: %.2lf\n", tempo_medio_espera_inicial);
    printf("Tempo médio de espera para finalizar cada processo: %.2lf\n", tempo_medio_espera_final);
    printf("Tempo total de processador: %d\n", tempo_total);

    free(temp_restante);
}

int main() {
    int n;
    printf("Quantos processos deseja cadastrar? ");
    scanf("%d", &n);

    Processo* processos = (Processo*)malloc(n * sizeof(Processo));
    for (int i = 0; i < n; i++) {
        printf("Nome do processo %d: ", i + 1);
        scanf("%s", processos[i].nome);
        printf("Tempo de execução do processo %d: ", i + 1);
        scanf("%d", &processos[i].tempo_execucao);
    }

    char algoritmo[20];
    printf("Qual algoritmo de escalonamento deseja utilizar? (FCFS/SJF/Circular): ");
    scanf("%s", algoritmo);

    if (strcmp(algoritmo, "FCFS") == 0) {
        fcfs(processos, n);
    } else if (strcmp(algoritmo, "SJF") == 0) {
        sjf(processos, n);
    } else if (strcmp(algoritmo, "Circular") == 0) {
        int quantum;
        printf("Informe o quantum: ");
        scanf("%d", &quantum);
        circular(processos, n, quantum);
    } else {
        printf("Algoritmo de escalonamento inválido.\n");
    }

    free(processos);
    return 0;
}