Scribd Logo
Upload

Welcome to Scribd!

  • 28 views

    Lecture On D.S

    Uploaded by

    Prince Shuv
    Linked lists are dynamic data structures that allocate memory separately for each element as needed, unlike arrays which allocate a single block of memory. Linked lists can grow and shrink in size more easily than arrays. They are appropriate when the number of elements is unpredictable. Each element consists of the data and a pointer to the next element. Common operations on linked lists include traversing the list, searching, inserting nodes, and deleting nodes.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd

    Lecture On D.S

    Uploaded by

    Prince Shuv
    28 views29 pages
    Linked lists are dynamic data structures that allocate memory separately for each element as needed, unlike arrays which allocate a single block of memory. Linked lists can grow and shrink in size more easily than arrays. They are appropriate when the number of elements is unpredictable. Each element consists of the data and a pointer to the next element. Common operations on linked lists include traversing the list, searching, inserting nodes, and deleting nodes.

    Original Description:

    DS lecture

    Original Title

    Lecture on D.S

    Copyright

    © © All Rights Reserved

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    Linked lists are dynamic data structures that allocate memory separately for each element as needed, unlike arrays which allocate a single block of memory. Linked lists can grow and shrink in size more easily than arrays. They are appropriate when the number of elements is unpredictable. Each element consists of the data and a pointer to the next element. Common operations on linked lists include traversing the list, searching, inserting nodes, and deleting nodes.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    28 views29 pages

    Lecture On D.S

    Uploaded by

    Prince Shuv
    Linked lists are dynamic data structures that allocate memory separately for each element as needed, unlike arrays which allocate a single block of memory. Linked lists can grow and shrink in size more easily than arrays. They are appropriate when the number of elements is unpredictable. Each element consists of the data and a pointer to the next element. Common operations on linked lists include traversing the list, searching, inserting nodes, and deleting nodes.

    Copyright:

    © All Rights Reserved
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    of 29

    Linked Lists

    Department of Computer Science and Engineering


    School of Engineering and Technology
    Kaziranga University, Koraikhowa, NH-37
    Jorhat-785006, Assam.
    [email protected]
    Linked List Basics
    Linked lists and arrays are similar since they both store
    collections of data.

    The array's features all follow from its strategy of


    allocating the memory for all its elements in one block of
    memory.

    Linked lists use an entirely different strategy: linked lists


    allocate memory for each element separately and only
    when necessary.

    2 M. H. Bhuyan Lec 20, 21, 22 and 23


    Disadvantages of Arrays
    The size of the array is fixed.
    In case of dynamically resizing the array from size S to
    2S, we need 3S units of available memory.
    Programmers allocate arrays which seem "large enough
    This strategy has two disadvantages: (a) most of the time
    there are just 20% or 30% elements in the array and 70%
    of the space in the array really is wasted. (b) If the
    program ever needs to process more than the declared
    size, the code breaks.
    Inserting (and deleting) elements into the middle of the
    array is potentially expensive because existing elements
    need to be shifted over to make room

    3 M. H. Bhuyan Lec 20, 21, 22 and 23


    Linked lists
    Linked lists are appropriate when the number of data elements
    to be represented in the data structure at once is unpredictable.

    Linked lists are dynamic, so the length of a list can increase or


    decrease as necessary.

    Each node does not necessarily follow the previous one


    physically in the memory.

    Linked lists can be maintained in sorted order by inserting or


    deleting an element at the proper point in the list.

    4 M. H. Bhuyan Lec 20, 21, 22 and 23


    Singly Linked Lists

    head

    next next next next


    a b c d

    First node Last node

    5 M. H. Bhuyan Lec 20, 21, 22 and 23


    Empty List
    Empty Linked list is a single pointer having the value of
    NULL.

    head = NULL;

    head

    6 M. H. Bhuyan Lec 20, 21, 22 and 23


    Basic Ideas
    Lets assume that the node is given by the following type
    declaration:
    struct Node {
    Object element;
    Node *next;
    };

    7 M. H. Bhuyan Lec 20, 21, 22 and 23


    Basic Linked List Operations
    List Traversal
    Searching a node
    Insert a node
    Delete a node

    8 M. H. Bhuyan Lec 20, 21, 22 and 23


    Traversing a linked list
    Node *pWalker;
    int count = 0;

    cout <<List contains:\n;

    for (pWalker=pHead; pWalker!=NULL;


    pWalker = pWalker->next)
    {
    count ++;
    cout << pWalker->element << endl;
    }

    9 M. H. Bhuyan Lec 20, 21, 22 and 23


    Searching a node in a linked list
    pCur = pHead;
    // Search until target is found or we
    reach
    // the end of list
    while (pCur != NULL &&
    pCur->element != target)
    {
    pCur = pCur->next;
    }
    //Determine if target is found
    if (pCur) found = 1;
    else found = 0;

    10 M. H. Bhuyan Lec 20, 21, 22 and 23


    Insertion in a linked list
    a b

    current
    x

    tmp = new Node;


    tmp->element = x;
    tmp->next = current->next;
    current->next = tmp;

    Or simply (if Node has a constructor initializing its members):


    current->next = new Node(x,current->next);
    11 M. H. Bhuyan Lec 20, 21, 22 and 23
    Deletion from a linked list

    a x b

    current

    Node *deletedNode = current->next;


    current->next = current->next->next;
    delete deletedNode;

    12 M. H. Bhuyan Lec 20, 21, 22 and 23


    Special Cases (1)
    Inserting before the first node (or to an empty list):
    tmp = new Node;
    tmp->element = x;
    if (current == NULL){
    tmp->next = head;
    head = tmp;
    }
    else { // Adding in middle or at end
    tmp->next = curent->next;
    current->next = tmp;
    }

    13 M. H. Bhuyan Lec 20, 21, 22 and 23


    Special Cases (2)
    Node *deletedNode;
    if (current == NULL){
    // Deleting first node
    deletedNode = head;
    head = head ->next;
    }
    else{
    // Deleting other nodes
    deletedNode = current->next;
    current->next = deletedNode ->next;
    }
    delete deletedNode;

    14 M. H. Bhuyan Lec 20, 21, 22 and 23


    Header Nodes
    One problem with the basic description: it assumes that
    whenever an item x is removed (or inserted) some
    previous item is always present.
    Consequently removal of the first item and inserting an
    item as a new first node become special cases to consider.
    In order to avoid dealing with special cases: introduce a
    header node (dummy node).
    A header node is an extra node in the list that holds no
    data but serves to satisfy the requirement that every node
    has a previous node.

    15 M. H. Bhuyan Lec 20, 21, 22 and 23


    List with a header node
    header

    a b c d

    Empty List
    header

    16 M. H. Bhuyan Lec 20, 21, 22 and 23


    Doubly Linked Lists

    pHead

    a b c

    Advantages:
    Convenient to traverse the list backwards.
    Simplifies insertion and deletion because you no longer
    have to refer to the previous node.
    Disadvantage:
    Increase in space requirements.
    17 M. H. Bhuyan Lec 20, 21, 22 and 23
    Deletion

    head current

    oldNode = current;
    oldNode->prev->next = oldNode->next;
    oldNode->next->prev = oldNode->prev;
    delete oldNode;
    current = head;

    18 M. H. Bhuyan Lec 20, 21, 22 and 23


    Insertion
    head current

    newNode = new Node(x); newNode


    newNode->prev = current;
    newNode->next = current->next;
    newNode->prev->next = newNode;
    newNode->next->prev = newNode;
    current = newNode;
    19 M. H. Bhuyan Lec 20, 21, 22 and 23
    Comparing Array-Based and Pointer-Based Implementations

    Size
    Increasing the size of a resizable array can waste storage and
    time
    Storage requirements
    Array-based implementations require less memory than a
    pointer-based ones

    20 M. H. Bhuyan Lec 20, 21, 22 and 23


    Comparing Array-Based and Pointer-Based Implementations

    Access time
    Array-based: constant access time
    Pointer-based: the time to access the ith node depends on i
    Insertion and deletions
    Array-based: require shifting of data
    Pointer-based: require a list traversal

    21 M. H. Bhuyan Lec 20, 21, 22 and 23


    Saving and Restoring a Linked List by Using a File

    Use an external file to preserve the list


    Do not write pointers to a file, only data
    Recreate the list from the file by placing each item at the
    end of the list
    Use a tail pointer to facilitate adding nodes to the end of the
    list
    Treat the first insertion as a special case by setting the tail to
    head

    22 M. H. Bhuyan Lec 20, 21, 22 and 23


    Circular Linked Lists
    Last node references the first node
    Every node has a successor
    No node in a circular linked list contains NULL

    A circular linked list

    23 M. H. Bhuyan Lec 20, 21, 22 and 23


    Circular Doubly Linked Lists
    Circular doubly linked list
    prev pointer of the dummy head node points to the last
    node
    next reference of the last node points to the dummy head
    node
    No special cases for insertions and deletions

    24 M. H. Bhuyan Lec 20, 21, 22 and 23


    Circular Doubly Linked Lists

    (a) A circular doubly linked list with a dummy head node


    (b) An empty list with a dummy head node

    25 M. H. Bhuyan Lec 20, 21, 22 and 23


    Processing Linked Lists Recursively
    Recursive strategy to display a list
    Write the first node of the list
    Write the list minus its first node
    Recursive strategies to display a list backward
    writeListBackward strategy
    Write the last node of the list
    Write the list minus its last node backward

    26 M. H. Bhuyan Lec 20, 21, 22 and 23


    Processing Linked Lists Recursively
    writeListBackward2 strategy
    Write the list minus its first node backward
    Write the first node of the list
    Recursive view of a sorted linked list
    The linked list to which head points is a sorted list if
    head is NULL or
    head->next is NULL or
    head->item < head->next->item, and
    head->next points to a sorted linked list

    27 M. H. Bhuyan Lec 20, 21, 22 and 23


    Problems
    Write an algorithm to insert a node after ith node in a
    linked list.
    Write an algorithm to delete an element from the linked
    list.

    28 M. H. Bhuyan Lec 20, 21, 22 and 23


    Questions?

    29 M. H. Bhuyan Lec 20, 21, 22 and 23

    You might also like