Einführung in die Verwendung rekursiver C#-Algorithmen_Häufig verwendete Anordnungen

1. Einführung in die Rekursion

Ein rekursiver Algorithmus ist ein Algorithmus, der direkt oder indirekt seine eigenen Funktionen oder Methoden aufruft.

Die Essenz des rekursiven Algorithmus besteht darin, das Problem in Teilprobleme desselben Typs zu zerlegen, deren Größe reduziert ist, und dann Methoden rekursiv aufzurufen, um die Lösung des Problems darzustellen. Rekursive Algorithmen eignen sich zur Lösung einer großen Klasse von Problemen und machen den Algorithmus prägnant und leicht verständlich.

Das Wesen der Rekursion ist Zirkularität und Zirkelschluss.

Rekursion ist eine mathematisch eigenständige und autonome Idee.

A. Zerlegen Sie das ursprüngliche Problem zur Verarbeitung in kleinere Probleme

Das zerlegte Problem ist genau vom gleichen Typ wie das ursprüngliche Problem, jedoch in einem kleineren Maßstab.

Durch die Lösung kleiner Probleme können wir leicht Lösungen für ursprüngliche Probleme finden.

B. Die Zerlegung des Problems ist begrenzt

Wenn Randbedingungen nicht erfüllt werden können, zerlegen Sie das Problem (Rekursion fortsetzen)

Wenn die Randbedingungen erfüllt sind, lösen Sie direkt (Rekursion endet).

2. Anwendung der Rekursion in der Programmierung

rekursive Funktion :

Im Funktionskörper befindet sich eine selbstaufrufende Funktion

Rekursive Funktionen müssen rekursive Ausgänge haben (Randbedingungen)

Eine unendliche Rekursion der Funktion führt zum Absturz des Programms

Wenn Sie rekursive Funktionen verwenden, sollten Sie sich nicht in den Implementierungsdetails der rekursiven Funktion verzetteln. Sie sollten zunächst das rekursive Modell erstellen und Randbedingungen festlegen.

3. Häufige Anwendungsszenarien rekursiver Algorithmen

1. Die Definition von Daten ist rekursiv definiert. Zum Beispiel: Fibonacci-Folge
2. Die Problemlösung wird durch einen rekursiven Algorithmus implementiert. Beispiel: rekursive Summierung
3. Die Strukturform von Daten wird rekursiv definiert. Wie Binärbäume, verallgemeinerte Tabellen usw.

4. Rekursive Nutzungsszenarien organisieren

1. Verwenden Sie Rekursion in Baumstrukturen

C#-Baumstruktur-Operationslogikanordnung

/// <summary>
/// 地区案例测试
/// </summary>
static void TestArea()
{
    List<Area> list = new List<Area>() {
        new Area(){ ID=1,Name="中国",ParentID=null},
        new Area(){ ID=2,Name="山东",ParentID=1},
        new Area(){ ID=3,Name="济南",ParentID=2},
        new Area(){ ID=4,Name="槐荫",ParentID=3},
        new Area(){ ID=5,Name="千乐微云",ParentID=4},

        new Area(){ ID=6,Name="市中区",ParentID=3},
        new Area(){ ID=7,Name="泉城广场",ParentID=6},
    };


    //转化为树结构展示
    var result = getChild(null, list);
    Console.WriteLine(result.ToJsonString());
}
/// <summary>
/// 递归处理子节点
/// </summary>
static List<Area> getChild(int? parentid, List<Area> source)
{
    List<Area> result = new List<Area>();
    //1.获取父节点
    List<Area> parent = source.Where(q => q.ParentID == parentid).ToList();
    if (parent.Count > 0)
    {
        //添加父类对象
        result.AddRange(parent);
        foreach (Area item in parent)
        {
            //循环父节点，获取子节点
            item.Children = getChild(item.ID, source);
        }
    }
    return result;
}

2. Rekursive Summierung

/// <summary>
/// 递归求和
/// </summary>
static int Sum(int num)
{
    if (num == 1)
        return 1;
    return num + Sum(num - 1);
}

//递归求和
Console.WriteLine(Sum(1));//1
Console.WriteLine(Sum(2));//3
Console.WriteLine(Sum(3));//6
Console.WriteLine(Sum(4));//10

3. Berechnen Sie die Fakultät rekursiv

/// <summary>
/// 递归阶乘
/// </summary>
static int Factorial(int num)
{
    if (num == 1)
        return 1;
    return num * Factorial(num - 1);
}


//递归阶乘
Console.WriteLine(Factorial(1));//1
Console.WriteLine(Factorial(2));//2
Console.WriteLine(Factorial(3));//6
Console.WriteLine(Factorial(4));//24

4. Implementieren Sie die Fibonacci-Folge rekursiv

Zu verbessern.....

5. Rekursive Implementierung der vollständigen Anordnung

Vollständige Kapselung des Permutationsalgorithmus (rekursiv).