Baunstruktur/Weg finden

DirkB

Globe schrieb:

Was ich nicht ganz verstehe ist, wie er auf das "return 1" reagiert?

Wie in main auch.
Du weist den Rückgabewert einer Variablen zu und reagierst entsprechend.

Globe schrieb:

(bitte nur Tipps und keine Lösung)

Reicht das denn?

Also ich hoffe, dass es reicht.
Aber auf einen Weg zum Abbrechen komme ich leider einfach nicht...

Folgende Idee liefert mir ein wunderbares Ergebnis:

int searchExit(node_t *T, int node_no){
    printf("-------------------\nKnoten: %d\n\nWerte: %d und %d\n\n", node_no, T[node_no].lnode, T[node_no].rnode);

if(T[node_no].lnode == (-1)){
    return 0;
} else{
    if(T[node_no].lnode == (-2)){
        return 1;
    } else{
        if(searchExit(T, T[node_no].lnode) == 1){
            return 1;
        }
    }
}

if(T[node_no].rnode == (-1)){
    return 0;
} else{
    if(T[node_no].rnode == (-2)){
        return 1;
    } else{
         if(searchExit(T, T[node_no].rnode) == 1){
            return 1;
        }
    }
}
}

DirkB

DirkB schrieb:

Und schalte mal die Compilerwarnungen auf Maximum.
Da muss (im jetzigen Zustand) eine Warnung kommen, dass die Funktion nicht in jedem Zweig ein return hat.

Deine Funktion hat nicht in jedem Zweig ein return!

Was ist z.B. wenn searchExit(T, T[node_no].rnode) eine 0 zurück gibt?

Du kannst das ganze viel einfacher machen, indem du nur schaust, ob der aktuelle Knoten gültig ist.

int searchExit(node_t *T, int node_no){

    if ( node_no == -1)
    { puts("Sackgasse");
      return 0;
    }
    if ( node_no == -2)
    { puts("Ausgang");
      return 1;
    }

    printf ("Knoten %d\n", node_no);

// Weder Ausgang noch Sackgasse, dann hat das Teil einen lnode und rnode.
// und die werden jetzt überprüft.
// und wenn einer einen Ausgang (1) hat, dann macht das die Oder-Verknüpfung

    return  searchExit(T, T[node_no].lnode) || searchExit(T, T[node_no].rnode);

}

Wenn bei lnode schon ein Ausgang gefunden wird, dann wird rnode nicht mehr überprüft.

Okay, danke. Ich schaus mir noch mal an.
Wobei heute ohnehin die Übung ist, in der unser Prof das genauer erklärt.

Aber danke für eure Hilfe!

Für interessierte und Leute mit ähnlichem Problem, die finale Lösung:

int searchExit(node_t *T, int node_no){

if(T[node_no].lnode == (-2) && T[node_no].rnode == (-2)){
    return 1;
}

if(T[node_no].lnode != (-1)){
        if(searchExit(T, T[node_no].lnode) == 1){
            printf("Knoten %d\n", node_no);
            return 1;
        }
}

if(T[node_no].rnode != (-1)){
         if(searchExit(T, T[node_no].rnode) == 1){
            printf("Knoten %d\n", node_no);
            return 1;
        }
}

}

DirkB

Globe schrieb:

Für interessierte und Leute mit ähnlichem Problem, die finale Lösung:

int searchExit(node_t *T, int node_no){

  if(T[node_no].lnode == (-2) && T[node_no].rnode == (-2)){
    return 1;
  }

  if(T[node_no].lnode != (-1)){
        if(searchExit(T, T[node_no].lnode) == 1){
            printf("Knoten %d\n", node_no);
            return 1;
        }
  }

  if(T[node_no].rnode != (-1)){
         if(searchExit(T, T[node_no].rnode) == 1){
            printf("Knoten %d\n", node_no);
            return 1;
        }
  }

  Was passiert, wenn die Funktion hier angekommen ist?
}

Das ist nicht vollständig und daher (wenn es von einem Lehrer kommt) Müll!

Ich hab es ja schon mehrfach geschrieben:
Welchen Wert gibt die Funktion zurück, wenn sowohl lnode als auch rnode -1 sind?
Oder wenn der jeweilige Aufruf von searchExit eine 0 zurück gibt?

Ein passendes T kann so aussehen:

node_t tree1 [] = { {-1, -1}, {-1, -1}, {-1, -1}, {-2,-2} };
node_t tree2 [] = { { 1,  2}, {-1, -1}, {-1, -1}, {-2,-2} };

damits schön ist solltest du noch die x vorkommen von

T[node_no]

durch eine Hilfsvariable ersetzen

node_t* node = T[node_no]

und diese node-Variable konsequent nutzen also

int searchExit(node_t *T, int node_no){

  node_t* node = &T[node_no]

  if(node->lnode == (-2) && node->rnode == (-2)){
    return 1;
  }

  if(node->lnode != (-1)){
        if(searchExit(T, node->lnode) == 1){
            printf("Knoten %d\n", node_no);
            return 1;
        }
  }

  if(node->rnode != (-1)){
         if(searchExit(T, node->rnode) == 1){
            printf("Knoten %d\n", node_no);
            return 1;
        }
  }

Also muss ich am Ende noch eine Überprüfung einfügen, für den Fall, dass beide -1 sind.

if(T[node_no].lnode == (-1) && T[node_no].rnode == (-1)){
    return 0;
}

DirkB

Globe schrieb:

Also muss ich am Ende noch eine Überprüfung einfügen, für den Fall, dass beide -1 sind.

Damit schaffst du wieder nur eine zusätlichen Zweig.

Was ist, wenn der auch nicht erfüllt ist (wenn die searchExit (aus Zeile 8 und 16) eine 0 zurück geben)?
Dann hast du wieder einnen Fall ohne return .

Warum prüfen?

Gib einfach 0 zurück

So einfach? Am Ende lediglich ein "return 0"?

DirkB

Globe schrieb:

So einfach? Am Ende lediglich ein "return 0"?

Ja.
Keinen Ausgang gefunden.
Bei den anderen Fällen hast du ja schon 1 zurück gegeben.