Geben Sie den Grad jedes Knotens in der angegebenen Prüfer-Sequenz aus

Drucken Sie den Grad jedes Zentrums in der gegebenen Prufer-Permutation aus und bereiten Sie sich darauf vor, Ereignisse für jeden Knoten durch die Permutation hervorzuheben und zu zählen. Indem wir die Rekursion für jeden Knoten verfolgen, bestimmen wir den Grad dieses Zentrums im entsprechenden beschrifteten Baum. Diese Daten geben Einblick in das Netzwerk und die Struktur des Baums. Indem Sie den Grad jedes Hubs ausdrucken, können Sie die Übertragung analysieren und die erforderlichen Hubs unterscheiden. Diese Untersuchung trägt wesentlich zum Verständnis der Eigenschaften und Merkmale des ursprünglichen Baums bei, der auf der Grundlage der Prüfer-Anordnung dargestellt wird.

Anwendungsmethode

• Frequenzzählmethode

• Adjazenzlistendarstellung

Frequenzzählmethode

Die Häufigkeitszählmethode zum Drucken des Grades jedes Hubs aus einer bestimmten Prüfer-Anordnung umfasst das Zählen der Ereignisse für jeden Hub, um seinen Grad zu bestimmen. Um diesen Ansatz zu implementieren, wird ein Wörterbuch oder Cluster initialisiert, um die Frequenzen der Zentren zu speichern. Wiederholen Sie die Prüfer-Anordnung und erhöhen Sie die Anzahl jedes erfahrenen Hubs. Die Anzahl jedes Hubs gibt seinen Grad im Tag-Baum an. Abschließend werden die Grade aller Hubs anhand wiederholter Kontrollen ausgedruckt. Diese Methode bietet eine klare Möglichkeit, die Verteilung der Netzwerk- und Hub-Grade innerhalb der Prüfer-Anordnung zu analysieren und die Strukturmerkmale des ersten Baums zu erhalten.

Algorithmus

• Initialisieren Sie eine klare Wortreferenz oder einen Cluster, um die Häufigkeit von Knoten zu speichern.

• Iterieren Sie über jedes Komponenten-„Zentrum“ in der Prüfer-Sequenz.

• Überprüfen Sie, ob „Hub“ im Wörterbuch oder Array vorhanden ist.

• Falls vorhanden, erhöhen Sie die Anzahl um 1.

• Wenn nicht vorhanden, fügen Sie es in eine Wortreferenz oder einen Cluster mit einer anfänglichen Anzahl von 1 ein.

• Sobald die Schleife abgeschlossen ist, können Sie die Frequenz jedes Zentrums in der Prüfer-Sequenz ermitteln.

• Durchlaufen Sie jedes Schlüssel-Wert-Paar in einer Wortreferenz oder einem Array.

• Schlüssel beziehen sich auf die Mitte, während sich das Selbstwertgefühl auf die Menge oder den Grad im Markerbaum bezieht.

• Drucken Sie die Mitte jedes Schlüssel-Wert-Paares und seinen Vergleichsgrad aus.

• Die aufgedruckten Hub-Grade veranschaulichen ihren spezifischen Grad im Tag-Baum.

Beispiel

#include <iostream>
#include <vector>

struct HubFrequency {
   int hub;
   int frequency;
};

void countFrequencies(const std::vector<int>& pruferSequence) {
   std::vector<HubFrequency> frequencyVector;

   for (int hub : pruferSequence) {
      bool found = false;
      for (HubFrequency& hf : frequencyVector) {
         if (hf.hub == hub) {
            hf.frequency++;
            found = true;
            break;
         }
      }

      if (!found) {
         frequencyVector.push_back({hub, 1});
      }
   }

   for (const HubFrequency& hf : frequencyVector) {
      std::cout << "Hub: " << hf.hub << ", Degree: " << hf.frequency << std::endl;
   }
}

int main() {
   std::vector<int> pruferSequence = {1, 2, 3, 1, 3};
   countFrequencies(pruferSequence);

   return 0;
}

Ausgabe

Hub: 1, Degree: 2
Hub: 2, Degree: 1
Hub: 3, Degree: 2

Adjazenzlistendarstellung

Die Darstellungsmethode der Adjazenzliste umfasst die Änderung der Prüfer-Gruppierung in die Adjazenzlisten-Informationsstruktur. Initialisieren Sie eine klare Adjazenzliste und fügen Sie für jede Komponente in der Prüfer-Sequenz einen Abschnitt zur Liste hinzu, der die Nachbarn dieses Knotens anzeigt. Behalten Sie beim Erstellen Ihrer Adjazenzliste die Häufigkeit jedes Hubs im Auge. Schließlich wird das Zentrum mit der höchsten Wiederholungsrate in der Adjazenzliste identifiziert und mit dem Zentrum mit dem höchsten Grad in der Prüfer-Gruppierung verglichen. Dieser Ansatz ermöglicht es uns, die Struktur von Adjazenzlisten und rekursiven Daten, die aus Prufer-Gruppierungen abgeleitet werden, zu nutzen, um die Kompetenz bei der Bestimmung von Hubs zu maximieren.

Algorithmus

• Initialisieren Sie eine leere Adjazenzliste und löschen Sie den Duplikatzähler.

• Iterieren Sie jede Komponente in der Prüfer-Sequenz:

• a. Erhöhen Sie den Wiederholungszähler des aktuellen Knotens.

• b. Bezieht den aktuellen Hub als Nachbarn des in der Sequenz genannten Hubs ein.

• Finden Sie im Wiederholungszähler das Zentrum mit der höchsten Wiederholungsfrequenz. Dieser Hub wird mit dem Hub mit dem größten Grad verglichen.

• Stellen Sie die Radnabe in ihrem maximalen Ausmaß wieder her.

Beispiel

#include <iostream>
#include <vector>
#include <unordered_map>

// Function to find the hub with the highest recurrence
int findHighestRecurrence(const std::unordered_map<int, int>& recurrenceCounter) {
   int highestRecurrence = 0;
   int hubWithHighestRecurrence = -1;

   for (const auto& entry : recurrenceCounter) {
      int hub = entry.first;
      int recurrence = entry.second;

      if (recurrence > highestRecurrence) {
         highestRecurrence = recurrence;
         hubWithHighestRecurrence = hub;
      }
   }

   return hubWithHighestRecurrence;
}

// Function to construct adjacency list from Prufer sequence
std::vector<std::vector<int>> constructAdjacencyList(const std::vector<int>& pruferSequence) {
   std::unordered_map<int, int> recurrenceCounter;
   std::vector<std::vector<int>> adjacencyList(pruferSequence.size() + 2);

   for (int hub : pruferSequence) {
      recurrenceCounter[hub]++;
      adjacencyList[hub].push_back(findHighestRecurrence(recurrenceCounter));
      adjacencyList[findHighestRecurrence(recurrenceCounter)].push_back(hub);
   }

   recurrenceCounter[findHighestRecurrence(recurrenceCounter)]++;

   return adjacencyList;
}

int main() {
   // Example Prufer sequence: {1, 3, 4, 2}
   std::vector<int> pruferSequence = {1, 3, 4, 2};
   std::vector<std::vector<int>> adjacencyList = constructAdjacencyList(pruferSequence);

   // Print the constructed adjacency list
   for (int i = 1; i < adjacencyList.size(); i++) {
      std::cout << "Node " << i << " connects to: ";
      for (int j = 0; j < adjacencyList[i].size(); j++) {
         std::cout << adjacencyList[i][j] << " ";
      }
      std::cout << std::endl;
   }

   return 0;
}

Ausgabe

Node 1 connects to: 1 1 
Node 2 connects to: 2 2 
Node 3 connects to: 3 3 
Node 4 connects to: 4 4 
Node 5 connects to: 

Fazit

Dieser Artikel veranschaulicht, wie der Grad jedes Zentrums in einer bestimmten Prufer-Gruppierung mit zwei verschiedenen Methoden gedruckt wird: der rekursiven Zählmethode und der Adjazenzlisten-Darstellungsmethode. Bei wiederholten Zählmethoden werden Ereignisse in jedem Zentrum innerhalb einer Gruppierung gezählt, um deren Ausmaß zu bestimmen. Die Adjazenzlisten-Darstellungsmethode entwickelt Adjazenzlisten basierend auf Permutationen und verfolgt die Duplizierung jedes Hubs, um den Hub mit dem bemerkenswertesten Grad zu ermitteln. Dieser Artikel enthält C-Code-Beschreibungen beider Methoden und erläutert deren Verwendung. Durch das Drucken von Nabengraden können wir die Gewebestruktur analysieren und kritische Naben in der Darstellung der Prüfer-Anordnung identifizieren.

Das obige ist der detaillierte Inhalt vonGeben Sie den Grad jedes Knotens in der angegebenen Prüfer-Sequenz aus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!