Scribd Logo
Upload

Welcome to Scribd!

  • 199 views

    Circular Link List in Java

    Uploaded by

    Manoj Kavedia
    - A circular linked list is a linked list where the last node's next pointer links to the first node, avoiding null references and enabling continuous traversal. - Operations on a circular linked list, like insertion and deletion, follow the same logic as a regular linked list but additionally require updating the last node to point to the first. - Circular linked lists can be useful for algorithms that repeat operations like playing audio/video in a loop or alt-tabbing in Windows. They allow starting traversal from any node.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOC, PDF, TXT or read online from Scribd

    Circular Link List in Java

    Uploaded by

    Manoj Kavedia
    199 views5 pages
    - A circular linked list is a linked list where the last node's next pointer links to the first node, avoiding null references and enabling continuous traversal. - Operations on a circular linked list, like insertion and deletion, follow the same logic as a regular linked list but additionally require updating the last node to point to the first. - Circular linked lists can be useful for algorithms that repeat operations like playing audio/video in a loop or alt-tabbing in Windows. They allow starting traversal from any node.

    Original Description:

    java

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    DOC, PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    - A circular linked list is a linked list where the last node's next pointer links to the first node, avoiding null references and enabling continuous traversal. - Operations on a circular linked list, like insertion and deletion, follow the same logic as a regular linked list but additionally require updating the last node to point to the first. - Circular linked lists can be useful for algorithms that repeat operations like playing audio/video in a loop or alt-tabbing in Windows. They allow starting traversal from any node.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    199 views5 pages

    Circular Link List in Java

    Uploaded by

    Manoj Kavedia
    - A circular linked list is a linked list where the last node's next pointer links to the first node, avoiding null references and enabling continuous traversal. - Operations on a circular linked list, like insertion and deletion, follow the same logic as a regular linked list but additionally require updating the last node to point to the first. - Circular linked lists can be useful for algorithms that repeat operations like playing audio/video in a loop or alt-tabbing in Windows. They allow starting traversal from any node.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as DOC, PDF, TXT or read online from Scribd
    Download as doc, pdf, or txt
    of 5

    Circular Link List in Java

    A linked list in which the last node points to the first node is called a circular linked list. Circular linked lists avoid the use of null references in their nodes. Can be useful for certain algorithms like playing video/audio files repeatedly and ALT + TAB in Windows. Successor of tail node is the head node. In doubly-linked list, predecessor of head node is the tail node. Insertions and deletions into a circular linked list follow the same logic patterns used in a singly linked list except that the last node must always point to the first node. Therefore, when inserting or deleting the last node, in addition to updating the tail pointer, we must also point the link field of the new last node to the first node.

    Advantage is that we can start searching from any node of the linked list and get to any other node. No logical head and tail pointers. However, we follow the conventions i.e., first element inserted into the list is given status of head and last element entered is called as a tail.

    Some characteristics of Circular Linked list are that the Last node references the first node, every node has a successor, and no node in a circular linked list contains NULL. Defining a Circular Linked List:
    #include <iostream> using namespace std; struct Node{ int data; Node* next; };

    Node* NodePtr;

    Insert into an empty Circular Linked list


    Node *loc = new Node; loc->data = 10; Tail = loc; Tail->next = Tail;

    Insert to head of a Circular Linked List


    loc->next = Tail1 >next; 2 Tail->next = loc;

    Insert to end of a Circular Linked List


    loc->next = Tail->next; Tail->next = loc; Tail = loc;

    Delete a node from a single-node Circular Linked List Cur = Tail;

    Tail = NULL; delete Cur;

    Delete the head node from a Circular Linked List


    Cur = Tail -> next; Tail->next = Cur->next delete Cur;

    Delete the end node from a Circular Linked List


    Prev->next = Tail->next; delete Tail; Tail = Prev;

    Example use of Circular Linked list


    Ever wonder what to do if the integer size required by your program is greater than 232, 264, 2512, 21024? 4294967296 and greater CANNOT be handled by primitive int data type. What we can do is make use of linked lists. To Add two such long integers, their digits are traversed from right to left. The corresponding digits are added and the possible carry is added to the next digit. We store the integers from right to left in a list so that the first node contains the least significant digit (rightmost). And the last node contains the most significant digit (leftmost). We keep five digits in each node.

    Algorithm First let the user input two long integers Store the two long integers in the lists Both lists are traversed in parallel, and five digits are added at a time If the sum of two 5 digits number is x, the lower order 5 digits of x can be extracted by using

    x % 100000

    The carry can be computed by integer division

    o x / 100000 largeInt* addint (largeint *int1, largeint *int2) { Node *p, q; int hunthou = 100000; int carry, number, total; largeint * sum; //defined to contain sum of p and q sum = new largeint; p = int1->Tail->Next; //p and q point to heads of list q = int2->Tail->Next; carry = 0; do { //add info of two nodes and previous carry total = p->data + q->data + carry; //Determine lower order five digits number = total % hunthou; insertRear(sum, number); //determine the carry carry = total / hunthou; p = p ->next; q = q->next } while ( p != int1->Tail->Next && q != int2->Tail->Next) while (p != int1->Tail->Next) { total = p->data + carry; number = total % hunthou; insertRear(sum, number); carry = total / hunthou; p = p->next; } while (q != int2->Tail->Next) { total = q->data + carry; number = total % hunthou; insertRear(sum, number); carry = total / hunthou; q = q->next; } if (carry == 1) { insertRear (sum, carry); } return sum; }

    You might also like