Dificuldade em corrigir erro em função...

[Ervilha]

Criei esse programa que simula um taskmanager, apenas para praticar "lista circular duplamente encadeada" então fiz com função.

Opção 1 - Incluir (Ela inclui um valor em string e armazena) [Funciona]

Opção 2 - Deletar (Deleta a string que deseja) [Funciona]

Opção 3 - Listar (Lista todas as strings em ordem alfabetica [Funciona]

Opção 4 - Executa (Essa opção deveria receber um valor em int, e fazer um loop alternando as strings até o final. EX. você entrou com "A-B-C" e ao executar essa opção colocou o numero 4 deveria fazer "A=1 B=1 C=1 A=2 B=2 C=2... etc...

mas ele só faz a primeira certinho A=1 B=1 C=1 eda estouro de memoria.)

Segue o codigo.

// Projeto_Veiculos.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <dos.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include <iostream>

/* ---------------------------------------------------------------- */

struct _no    // define a estrutura do processo
{
    struct _no *anterior;
    char nome[40];
    struct _no *proximo;
};

/* ---------------------------------------------------------------- */

typedef struct _no No;

No *Raiz=NULL;        // define um ponteiro para o numero raiz
No *Ultimo=NULL;    // define um ponteiro para o ultimo numero

/* ---------------------------------------------------------------- */

void Insere(char *nome) 
{
    No *Atual;
    No *NoAnterior;
    No *NoPosterior;
    No *NovoNo;

    // Verifica se o nó na raiz é nulo, que é o caso quando a lista está vazia.
    // Se for, cria nó na raiz com os dados fornecidos e faz o último nó coincidir com ele.
    if (Raiz==NULL) 
    {
        Raiz = new No;
        strcpy (Raiz->nome,nome);
        Raiz->proximo = NULL;
        Raiz->anterior = NULL;
        Ultimo = Raiz;
    }
    else 
    {  
        // se já houver raiz percorre a lista duplamente encadeada, comecando da raiz.
        // inicialmente, não há nó anterior.
        NoAnterior = NULL;
        Atual = Raiz;
        while (Atual!=NULL) 
        {
            if (strcmp(Atual->nome,nome)>=0) break; // verifica se o nó atual é igual, se for superior pára
            else 
            {
                NoAnterior = Atual;
                Atual = Atual->proximo;
            }
        }

        if (Atual!=NULL) // só faz a comparação abaixo se existe o nó Atual
            if (strcmp(Atual->nome,nome)==0) 
            {
                printf ("\n\n Nome já existente!\n");
                printf ("\n\n\n\n ");
                system("pause");
                system("cls");
                return;
            }

            NoPosterior = Atual;        // insere um novo nó entre o nó atual e o nó anterior        
            NovoNo = new No;            // aloca memória para o novo nó            
            strcpy (NovoNo->nome,nome);    // coloca dados no nó a ser inserido

            // atualiza ponteiros do novo nó
            NovoNo->proximo = NoPosterior;    
            NovoNo->anterior = NoAnterior;

            // atualiza ponteiros dos nós vizinhos
            if (NoAnterior != NULL)            
                NoAnterior->proximo = NovoNo;
            if (NoPosterior != NULL)
                NoPosterior->anterior = NovoNo;

            // verifica se o novo nó foi inserido no início ou no fim da lista se foi, atualiza referências
            if (NovoNo->anterior == NULL)
                Raiz = NovoNo;
            if (NovoNo->proximo == NULL)
                Ultimo = NovoNo;
    }
}

/* ---------------------------------------------------------------- */

void Lista() 
{
    No *Atual;
    Atual = Raiz;
    // percorre a lista duplamente encadeada desde a raiz
    while(Atual!=NULL) 
    {
        printf ("\n Processo: %s\n",Atual->nome);
        Atual=Atual->proximo;
    }
    printf ("\n\n\n\n ");
    system("pause");
    system("cls");
}

/* ---------------------------------------------------------------- */

void Deleta(char *nome) 
{
    No *Atual;
    No *Anterior=NULL;
    No *Posterior;

    Atual = Raiz;

    // primeiro, percorre a lista duplamente encadeada desde a raiz
    while (Atual!=NULL) 
    {
        // verifica se já encontrei ou já passei do nome procurado
        if (strcmp(Atual->nome,nome)>=0) break;
        else  
        {  // se ainda não passou
            Anterior = Atual;
            Atual = Atual->proximo;
        }
    }

    if (Atual!=NULL)
        Posterior = Atual->proximo;

    // verifica se o nó atual é mesmo o nó procurado
    if (Atual != NULL)
        if (strcmp(Atual->nome,nome)==0) {  // se for, deleta
            // faz com que o nó subsequente ao atual seja o subsequente ao nó anterior para manter a integridade da lista
            if (Atual != Raiz)
                Anterior->proximo = Atual->proximo;
            else  // se o no atual é a raiz, atualizo a referência para a raiz
                Raiz = Atual->proximo;
            // faz com que a referência para o nó anterior do próximo nó seja
            // o nó anterior ao que será deletado, para manter a integridade
            if (Atual != Ultimo)
                Posterior->anterior = Anterior;
            else  // se o nó atual é o último, atualiza a referência para o último
                Ultimo = Anterior;
            // agora, o nó atual morreeeee!!!!
            free(Atual);
            printf ("\n\n Nome deletado! \n\n");
            printf ("\n\n\n\n ");
            system("pause");
            system("cls");
            return;
        }

        printf("\n\n não achei!\n");
        printf ("\n\n\n\n ");
        system("pause");
        system("cls");
}

/* ---------------------------------------------------------------- */

void Executa() 
{        
    int Ciclos, Qtde;

    No *Atual;
    Atual = Raiz;

    Ciclos=1;
    Qtde=1;

    if (Raiz!=NULL)
    {
        // recebe o valor para executar o loop solicitado
        printf("\n\n Entre com a quantidade de ciclos desejada: " ); 
        scanf("%i", &Qtde);
    
        while(Ciclos<Qtde)    // verifica quando o loop é encerrado
        {
            if (Atual==Raiz)
            {                        
                Ciclos++;
            }

            printf(" Processo: %s | Qtde: %d | Ciclo: %i \n", Atual->nome, Qtde, Ciclos-1);
            Atual = Atual->proximo;
            Sleep(500);
        }                    
    }
    else
    {
        printf("\n\n não existem processos na lista!");
    }
    printf("\n\n\n\n ");
    system("pause");
    system("cls");
    Qtde=0;
    Ciclos=1;
}

/* ---------------------------------------------------------------- */

void main () 
{
    int opcao;
    char nome[40];

    do 
    {
        printf("\n\n ****************** MENU ****************** \n (1) -> para inserir um novo processo:\n (2) -> para excluir um processo:\n (3) -> para listar todos os processos: \n (4) -> para executar os processos: \n (0) -> para sair \n ****************************************** \n\n Opcao: ");
        scanf("%d",&opcao);

        if (opcao == 1 || opcao == 2) 
        {
            printf("\n\n Entre com o nome do processo: " );
            scanf("%s",nome);
            system("cls");
        }

        switch (opcao) 
        {
        case 1: 
            {
                Insere(nome); 
                break;
            }

        case 2: 
            {
                Deleta(nome); 
                break;
            }
        case 3: 
            {
                Lista(); 
                break;
            }
        case 4: 
            {
                Executa(); 
                break;
            }

        }
    } while (opcao != 0);

} 

/* ---------------------------------------------------------------- */

[ursolouco]

Salve,

Já deu uma olhada no valor de seu Ciclos na hora em que ele realiza a subtração ?

Abraços