Lista okrągła w C ++

Możemy umieścić elementy na okrągłej listy połączonej z dowolnego miejsca na liście; Nie możemy jednak wstawić elementów do tablicy z dowolnego miejsca na liście, ponieważ jest ona w ciągłej pamięci. Ostatni element na okrągłej liście połączonej utrzymuje adres następnego elementu, podczas gdy ostatni element zachowuje adres pierwszego elementu. Kołowy łańcuch powstaje przez elementy odnoszące się do siebie w okrągłym wzorze.

Ponieważ okrągła lista połączona ma rozmiar dynamiczny, pamięć może być przydzielona tylko wtedy, gdy jest potrzebna. Artykuł będzie zademonstrować okrągłą listę połączoną z ilustracjami programu C ++ w C++.

Zastosowanie okrągłej listy połączonej

Okrągła lista połączona to taka, w której wszystkie węzły są połączone w okręgu. Nie ma elementu zerowego na okrągłej liście połączonej. Punktem początkowym może być dowolny węzeł. Zaczynając od dowolnego miejsca na liście, możemy przemierzać całą listę. Wszystko, co musimy teraz zrobić, to poczekać, aż pierwszy węzeł zostanie ponownie osiągnięty. Tam mamy pewne zastosowania okrągłej listy połączonej w następujący sposób:

1. Nasze komputery osobiste, które uruchamiają kilka aplikacji, są przykładem tego, w jaki sposób lista okrągła jest wykorzystywana w prawdziwym życiu. Wszystkie uruchomione aplikacje są przechowywane na okrągłej listy połączonej, a system operacyjny przypisuje każdy z nich określony przedział czasowy do wykonania. System operacyjny nadal zapętla się nad połączoną listą, dopóki wszystkie programy nie zostaną wykonane.
2. Gry wieloosobowe to kolejny doskonały przykład. Wszyscy gracze są przechowywani na okrągłej listy powiązanej, a wskaźnik porusza się, gdy wygasa okazja każdego gracza.
3. Okrągła kolejka może być również utworzona za pomocą okrągłej listy połączonej. Musimy zachować zarówno wskaźniki, z przodu, jak i z tyłu, w pamięci przez cały czas w kolejce, ale potrzebna jest tylko jeden wskaźnik na okrągłej liście połączonej.

Przykład 1: Tworzenie okrągłego połączonej listy przemieszczania się w C++

Jedyną różnicą jest to, że na okrągłej liście połączonej węzeł w ostatniej pozycji będzie miał swój następny link do głowicy listy, podczas gdy na liniowej listy Lined, ostatni węzeł miałby następny punkt do dołu dolnej części Lista. Implementacja okrągłego połączonego kodu przemieszczania listy w C ++ pokazano poniżej.

W pierwszym etapie zdefiniowaliśmy klasę jako „węzeł”, w którym ogłosiliśmy zmienną Int jako „mydata”. Zmienna „mydata” to dane dla węzła. Wskaźnik jest również zadeklarowany w tej klasie jako „Następny” dla wskaźnika do następnego węzła na liście okrągłych.

Po klasie „węzeł” mamy funkcję o nazwie „Push”, która wkłada węzeł na początku listy okrągłych. Zdefiniowaliśmy konstruktor, który przekazuje odniesienie wskaźnika Head_Node w klasie „węzeł” i zmienną „mydata” jako parametr. Nowy wskaźnik jest tworzony jako „MyPtr”, który nazwał i przypisał „węzeł”.

Następnie wskaźnik temperatury jest deklarowany jako „temp”, który ma head_node. Istnieją wskaźniki, takie jak „ptr1” i „ptr2”, które nazywane są „mydata” i wskaźnik „następny” i biorą ich adresy. Następnie mamy instrukcję IF, w którym jest tylko_node head, i jest ono trzymane null. Jeśli okrągła lista połączona jest zerowa, dodaj następny do ostatniego węzła za pomocą pewnej pętli. W przeciwnym razie instrukcja zostanie wykonana, w której głowa wskazuje na pierwszy węzeł listy.

Następnie stworzyliśmy inną funkcję jako „Displaylist”, aw konstruktorze tej funkcji właśnie przekazaliśmy głowę węzłów okrągłej listy połączonej. Funkcja wyświetli węzły na okrągłej listy połączonej za pośrednictwem pętli do-podczas instrukcji IF, która ma warunek, że głowa węzła nie powinna być równa NULL.

Wreszcie istnieje główna metoda, która przetestuje wdrożenie opisane wcześniej. Głowa wskaźnika klasy „węzeł” została ustawiona na „null” w głównej metodzie. Następnie dodaj dane do połączonej listy za pomocą metody push (). „Głowa” jest przekazywana do funkcji „Displaylist”, która wyświetli listę okrągłą połączoną.

#włączać
za pomocą przestrzeni nazw Std;
Węzeł klasy

publiczny:
int mydata;
Węzeł *następny;
;
void push (węzeł ** head_node, int mydata)

Węzeł *myptr1 = new node ();
Węzeł *temp = *head_node;
MyPtr1-> mydata = mydata;
MyPtr1-> następny = *head_node;
if (*head_node != Null)

While (temp-> następny != *head_node)
temp = temp-> następny;
temp-> następny = myPtr1;

w przeciwnym razie
MyPtr1-> Next = MyPtr1;
*head_node = myPtr1;

void wyświetlacz (głowa węzła *)

Węzeł *temp = head;
if (głowa != Null)

Do

Cout
When (temp != głowa);


int main ()

Węzeł *head = null;
Push (i Head, 2001);
Push (i Head, 2015);
Push (i Head, 2006);
push (i głowa, 2022);
Cout<< "Circular Linked List:\n ";
DisplayList (głowa);
Cout<< "\n ";
powrót 0;

Okrągła lista połączona zaimplementowana w powyższym wyjściu kodu jest wyświetlana na następującym obrazie.

Przykład 2: Podziel okrągłą listę połączoną na dwie połowy w C++

Poniższy program umożliwia podział okrągłej listy połączonej na dwie części możliwe. Spójrzmy na implementację, w jaki sposób podzieliliśmy listę okrągłą połączoną w C++.

Najpierw mamy klasę „węzeł”, w której zdefiniowaliśmy zmienną „elementy”, a wskaźnik „następny” węzła. Członkowie klasy „węzeł” są publiczni w tym programie. Następnie zbudowaliśmy funkcję zwaną „halvelist”, w której od samego początku dzieliśmy listę z głową na dwie listy. Head1_Node i Head2_Node są odniesieniami do dwóch wynikających z powiązanych węzłów listy.

W funkcji zadeklarowaliśmy dwa wskaźniki, „s_ptr” i „f_ptr”, które ma głowę listy powiązanej. Jeśli instrukcja IF jest używana dla węzła głównego zawierającego wartość zerową, to mamy pewną pętlę, która stwierdza, że ​​f_ptr-> następny staje się głową, jeśli lista okrągła ma dziwne węzły, a f_ptr-> następny-> następny staje Lista zawiera nawet węzły.

Po pętli While ponownie użyliśmy instrukcji IF, w której warunek brzmi: „Jeśli lista zawiera parzystą liczbę elementów, F_PTR należy przenieść i ustawić wskaźnik Head1_Node pierwszej połowy”. W następnej instrukcji IF ustawiliśmy Head2_Node na drugą połowę listy połączonej.

Przypisaliśmy S_PTR-> obok f_ptr-> obok, aby drugi połowę cyrkularny listy, a następnie S_PTR-> jest utrzymywane równe głowicy listy i sprawia, że ​​pierwsza połowa okrąg.

Druga funkcja jest tworzona jako „push”, która jest wykorzystywana do wstawienia węzła na początku okrągłej listy z tą funkcją. W funkcji warunek implikuje, czy head_node of okrągła lista połączona nie jest null, a następnie ustaw obok ostatniego węzła. Trzecia funkcja, „Displaylist”, jest generowana dla wyświetlania okrągłej listy połączonej.

Następnie mamy główną funkcję, w której zainicjowaliśmy głowę, głowę1_node i head2_node pusty. Metoda push jest używana do wstawienia wartości na połączonej liście, a za pośrednictwem polecenia Cout, okrągła lista połączona i podzielona okrągła lista będzie wyświetlana.

#włączać
za pomocą przestrzeni nazw Std;
Mynode klasy

publiczny:
Przedmioty int;
MyNode *następny;
;
void halvelist (głowa MyNode *, MyNode ** Head1_Node, MyNode ** Head2_Node)

MyNode *s_ptr = head;
MyNode *f_ptr = head;
if (head == null)
powrót;
while (f_ptr-> następny != Head &&
f_ptr-> następny-> następny != głowa)

f_ptr = f_ptr-> następny-> następny;
s_ptr = s_ptr-> następny;

if (f_ptr-> następny-> następny == head)
f_ptr = f_ptr-> następny;
*head1_node = head;
if (head-> następny != głowa)
*head2_node = s_ptr-> następny;
f_ptr-> następny = s_ptr-> następny;
s_ptr-> następny = head;

void push (MyNode ** Head_node, int Items)

MyNode *newptr = new MyNode ();
MyNode *temp = *head_node;
Newptr-> items = items;
Newptr-> następny = *head_node;
if (*head_node != Null)

While (temp-> następny != *head_node)
temp = temp-> następny;
temp-> następny = newptr;

w przeciwnym razie
Newptr-> następny = newptr; / *Dla pierwszego MyNode */
*head_node = newptr;

void wyświetlacz (głowa MyNode *)

MyNode *temp = głowa;
if (głowa != Null)

Cout<Do
Cout while (temp != głowa);


int main ()

int myListize, ja;
MyNode *head = null;
MyNode *Head1 = null;
MyNode *head2 = null;
push (i głowa, 10);
push (& head, 90);
push (i głowa, 40);
push (i głowa, 70);
Cout<< "Circular Linked List";
DisplayList (głowa);
Halvelist (głowa i głowa 1 i head2);
Cout<< "\nFirst Halve Circular Linked List";
DisplayList (Head1);
Cout<< "\nSecond Halve Circular Linked List";
DisplayList (Head2);
powrót 0;

Tutaj mamy wyjście oryginalnej okrągłej listy połączonej, wyjście pierwszej półkolistej listy i drugiej połowy okrągłej listy połączonej.

Przykład 3: sortowanie okrągłej listy połączonej w C++

W pierwszym etapie mamy klasę „Nodelist”, która zawiera zmienne członkowskie i wskaźniki w klasie. Następnie utworzyliśmy funkcję „SortInserition”, która wprowadza nowy węzeł na posortowanej liście. Ta funkcja wymaga wskaźnika do węzła głównego, ponieważ może zmienić głowę listy wejściowej.

Następnie mamy instrukcję IF dla Nodelist, która zawiera tylko węzeł. Punkt_nodowy do nowego węzła. W instancji, jeśli instrukcja przypisaliśmy dane Nodelist do bieżącego.

Tutaj dodaje się nowy węzeł przed węzłem głównym. Blok if-Else ma pętlę w czasie, która ma warunek; Jeśli wartość jest mniejsza niż wartość głowy, następny lub ostatni węzeł musi zostać zmieniony. Pętla While zidentyfikuje węzeł przed punktem wstawienia.

Następnie stworzyliśmy nowy_nodelistę, następny węzeł, który lokalizuje następny węzeł wskaźnika. Następnie, aktualnie-> Następnie musimy zmienić lokalizację wskaźnika na następny. Do drukowania węzłów z listy połączonej nazwali funkcję „showlist”.

Ostatecznie mamy główną funkcję, w której zainicjowaliśmy tablicę i iterowało nad określoną tablicą, która będzie sortowaną tablicą.

#włączać
za pomocą przestrzeni nazw Std;
Nodelista klasowy

publiczny:
wartości int;
Nodelist *następny;
;
void sortInserition (Nodelist ** Head_node, Nodelist* New_Nodelist)

NodElist * current = * head_node;
if (current == null)

new_nodelist-> następny = new_nodelist;
*head_node = new_nodelist;

else if (current-> wartości> = new_nodelist-> wartości)

While (Current-> następny != *head_node)
current = current-> następny;
Current-> następny = new_nodelist;
new_nodelist-> następny = *head_node;
*head_node = new_nodelist;

w przeciwnym razie

While (Current-> następny!= *head_node &&
Current-> Next-> Wartości)
current = current-> następny;
new_nodelist-> następny = current-> następny;
Current-> następny = new_nodelist;


void showlist (Nodelist *Begin)

Nodelist *Temp;
if (zacznij != Null)

temp = początek;
Do
Cout while (temp != początek);


int main ()

int myarr [] = 31, 5, 23, 99, 30;
int List_Size, i;
Nodelist *początek = null;
Nodelist *Temp;
for (i = 0; ivivalues ​​= myarr [i];
SortInserition (i początek, temp);

Cout<<"Sorted Circular Linked List:\n";
lista show (początek);
Cout<<"\n";
powrót 0;

Sortowana okrągła lista połączona jest wyświetlana na poniższym ekranie Ubuntu.

Wniosek

To kończy naszą dyskusję na temat wkładania, dzielenia i sortowania węzłów na okrągłej liście połączonej w C++. W wielu aplikacjach używana jest okrągła lista połączona. Mam nadzieję, że pomoże ci to usunąć dwuznaczność związaną z okrągłą listą połączoną w C++.