triangle number, problem ze zrozumieniem rekurencji w konkretnym przykładzie

cześć,
przerabiam książkę o strukturach danych i algorytmach i mam taki przykład:

rekurencja przy szukaniu "triangular number" https://en.wikipedia.org/wiki/Triangular_number
kod w javie:

public static int triangle(int n) {

        System.out.println("Entering: n = " + n);
        if (n == 1) {
            System.out.println("Returning 1");
            return 1;
        } else {
            int temp = n + triangle(n - 1);
            System.out.println("Returning " + temp);
            return temp;
        }
    }

wklejam tylko tą metodę, reszta kodu jest chyba nie ważna
to jak działa rekurencja to ja rozumiem, funkcja wywołuje samą siebie,
użyłem debugera, aby zobaczyć jak działa kod i mam problem w momencie gdy n jest równe 1 czyli warunek w ifie się zgadza (n==1), dalej drukuje i tutaj zwraca 1 i w tym momencie nie rozumiem dlaczego program wchodzi do bloku else, skoro dla n = 1 warunek został wykonany? Klikam dalej w debugera i następnie widzę n = 2. Jak to się stało że n powiedzmy z 5 zeszło do 1 i potem nagle inkrementuje się o 1? czyli n = 2, potem 3 itd

Zastanawiałeś się nad sensem słowa kluczowego return? Funkcja wykonała się więc wraca do poprzedniej wraz z jej wynikiem. Tam gdzie jest wywołanie funkcji jest wstawiany jej wynik.

dalej nie rozumiem dlaczego po zejściu np od 5 do n = 1 potem mam n++, skąd się bierze ta n = 2?
tutaj cały kod + output

package recursion;

import java.io.*;

public class TriangleApp {
    static int theNumber;

    public static void main(String[] args) throws IOException {
        System.out.println("Enter a number: ");
        theNumber = getInt();
        int theAnswer = triangle(theNumber);
        System.out.println("Triangle = " + theAnswer);
    }

    public static int triangle(int n) {

        System.out.println("Entering: n = " + n);
        if (n == 1) {
            System.out.println("Returning 1");
            return 1;
        } else {
            int temp = n + triangle(n - 1);
            System.out.println("Returning " + temp);
            return temp;
        }
    }

    public static String getString() throws IOException {
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(isr);
        String s = br.readLine();
        return s;
    }

    public static int getInt() throws IOException {
        String s = getString();
        return Integer.parseInt(s);
    }
}

output:

Enter a number:
5
Entering: n = 5
Entering: n = 4
Entering: n = 3
Entering: n = 2
Entering: n = 1
Returning 1
Returning 3
Returning 6
Returning 10
Returning 15
Triangle = 15

Lepiej to będzie widać w pseudokodzie:

def triangle(n):
    if n == 1:
        return 1
    else:
        return n + triangle(n - 1)

Teraz mozna to łatwo prześledzić dla jakiejś małej liczby, niech będzie 3:
Najpierw trzy razy wykonuje się linia 5, czyli tworzy się wyrażenie 3 + 2 + 1,[to nie tworzy się od razu, najpierw jest 3 + f(2), potem 3 + 2 + f(1) i tak dalej ewentualnie] w ostatnim wywołaniu funkcja wchodzi w linię 2 i zwraca jeden i teraz dopiero, jak już jest ostatnia wartość (base case, tu równe 1) zwracany jest ostateczny wynik 1 + 2 + 3, czyli 6. W Twoich instrukcjach println("Returning" + temp) Widzisz częsciowe sumy od końca, jak funkcja "wraca" z rekurencji, stąd rosnący ciąg [sum - sumy musza rosnąć:)]

Edit:
Nie Musisz się tu zatrzymywać, zmieniając + na *, Możesz sobie policzyć silnię:

def fact_recur(n):
    if n == 1:
        return 1
    else:
        return n  * fact_recur(n - 1)

Albo sumę kwadratów:

def square_sum(n):
    if n == 1:
        return 1
    else:
        return n * n  + square_sum(n - 1)

Lub zsumować dowolne operacje na n:

def g(n):
    """funkcja jednej zmiennej zwracająca cos co mozna dodawać"""

def function(n, f):
    if n == 1:
        return 1
    else:
        return f(n)  + function(n - 1)
print(function(3, g))

Mógłbyś iśc jeszcze dalej i z tych funkcji zbudować sobie metafunkcję, która bierze ciąg wejściowy i w dowolny sposób (jak tylko, oczywiście będą się zgadzać typy, żeby nie robić czegoś bezsensownego, np. mnozyć stringów) składa w jakiś wynik elementy wejściowe.

Żeby zrozumieć rekurencję, trzeba zrozumieć rekurencję. Wydaje ci się tylko, że ją rozumiesz, a prawda jest taka, że jesteś w ciemnym lesie i nic nie rozumiesz. Ale spokojnie, jesteśmy tu po to, aby takim jak ty pomóc.

Funkcja rekurencyjna nie może zwrócić wartości funkcji triangle(5), dopóki gdy wszystkie wywołania wewnętrzne nie zwrócą wartości. Funkcja rekurencyjna dla n = 5 dochodzi do linijki

int temp = 5 + triangle(4);

i sobie myśli: "kur@# ale ja nie wiem ile jest triangle(4)" i wywołuje funkcję triangle(4) po czym znów dochodzi do linijki

int temp = 4 + triangle(3);

i sobie myśli "ja pier@#$ co ten programista to ja nie wiem, skąd mam wiedzieć ile jest triangle(3)?" i wywołuje triangle(3) po czym znów dochodzi do linijki

int temp = 3 + triangle(2);

i sobie myśli "kur@# skąd mam wiedzieć ile jest triangle(3) i wywołuje funkcje triangle(2) po czym znów dochodzi do linijki

int temp = 2 + triangle(1);

i sobie myśli "coraz więksi amatorzy biorą się za programowanie, ja przecież nie wiem ile wynosi triangle(1) po czym dochodzi do kodu:

if (n == 1) {
            System.out.println("Returning 1");
            return 1;
        }

i sobie myśli "oooo w końcu ten durny programista zwrócił mi jakąś wartość! Teraz mogę policzyć resztę!" i sobie wraca do kodu dla n= 2 ponieważ go nie skończył:

            int temp = 2 + triangle(1);
            System.out.println("Returning " + temp);
            return temp;

i sobie myśli "O! Teraz to jest kulturka, teraz już wiem ile wynosi triangle(1), więc mogę dodać 2 i mam teraz policzony temp" i sobie dodaje int temp = 2 + triangle(1), wychodzi mu 3 i sobie wraca do kodu dla n=3, ponieważ go nie skończył:

            int temp = 3 + triangle(2);
            System.out.println("Returning " + temp);
            return temp;

i sobie myśli "Fajowo, teraz już wiem, że triangle(2) wynosi 3, więc mogę sobie dodać 3 + triangle(2) i wiem ile to będzie!" i sobie dodaje int temp = 3 + triangle(2), wychodzi mu 6 i sobie wraca do kodu dla n=4, ponieważ go nie skończył:

            int temp = 4 + triangle(3);
            System.out.println("Returning " + temp);
            return temp;

i sobie myśli "Panie, teraz to już łatwe. Wiem, że triangle(3) wynosi 6, więc sobie mogę dodać 4 + triangle(3) i wiem, że będzie 10" i sobie dodaje, wychodzi mu 10 i sobie wraca do kodu dla n=5, ponieważ go nie skończył:

            int temp = 5 + triangle(4);
            System.out.println("Returning " + temp);
            return temp;

i sobie myśli "Teraz już wiem wszystko! Wiem, że triangle(4) wynosi 10, więc sobie mogę dodać 5 i mam ostateczny wynik".

dziękuje za odpowiedzi, już rozumiem ;)