Question

In: Computer Science

Write in C++: create a Doubly Linked List class that holds a struct with an integer...

Write in C++:

create a Doubly Linked List class that holds a struct with an integer and a string. It must have append, insert, remove, find, and clear.

Expert Solution

```
#include<iostream>
```
```
#include<cstdio>
```
```
#include<cstdlib>
```
```
/*
```
```
 * Node Declaration
```
```
 */
```
```
using namespace std;
```
```
struct node
```
```
{
```
```
    int info;
```
```
    struct node *next;
```
```
    struct node *prev;
```
```
}*start;
```
```
 
```
```
/*
```
```
 Class Declaration 
```
```
 */
```
```
class double_llist
```
```
{
```
```
    public:
```
```
        void create_list(int value);
```
```
        void add_begin(int value);
```

        void add_after(int value, int position);

```
        void delete_element(int value);
```
```
        void search_element(int value);
```
```
        void display_dlist();
```
```
        void count();
```
```
        void reverse();
```
```
        double_llist()
```
```
        {
```
```
            start = NULL;  
```
```
        }
```
```
};
```
```
 
```
```
/*
```
```
 * Main: Conatins Menu
```
```
 */
```
```
int main()
```
```
{
```
```
    int choice, element, position;
```
```
    double_llist dl;
```
```
    while (1)
```
```
    {
```

        cout<<endl<<"----------------------------"<<endl;

        cout<<endl<<"Operations on Doubly linked list"<<endl;

        cout<<endl<<"----------------------------"<<endl;

```
        cout<<"1.Create Node"<<endl;
```

        cout<<"2.Add at begining"<<endl;

        cout<<"3.Add after position"<<endl;

```
        cout<<"4.Delete"<<endl;
```
```
        cout<<"5.Display"<<endl;
```
```
        cout<<"6.Count"<<endl;
```
```
        cout<<"7.Reverse"<<endl;
```
```
        cout<<"8.Quit"<<endl;
```
```
        cout<<"Enter your choice : ";
```
```
        cin>>choice;
```
```
        switch ( choice )
```
```
        {
```
```
        case 1:
```

            cout<<"Enter the element: ";

```
            cin>>element;
```
```
            dl.create_list(element);
```
```
            cout<<endl;
```
```
            break;
```
```
        case 2:
```

            cout<<"Enter the element: ";

```
            cin>>element;
```
```
            dl.add_begin(element);
```
```
            cout<<endl;
```
```
            break;
```
```
        case 3:
```

            cout<<"Enter the element: ";

```
            cin>>element;
```

            cout<<"Insert Element after postion: ";

```
            cin>>position;
```

            dl.add_after(element, position);

```
            cout<<endl;
```
```
            break;
```
```
        case 4:
```
```
            if (start == NULL)
```
```
            {                      
```

                cout<<"List empty,nothing to delete"<<endl;

```
                break;
```
```
            }
```

            cout<<"Enter the element for deletion: ";

```
            cin>>element;
```
```
            dl.delete_element(element);
```
```
            cout<<endl;
```
```
            break;
```
```
        case 5:
```
```
            dl.display_dlist();
```
```
            cout<<endl;
```
```
            break;
```
```
        case 6:
```
```
            dl.count();
```
```
            break;    
```
```
        case 7:
```
```
            if (start == NULL)
```
```
            {
```

                cout<<"List empty,nothing to reverse"<<endl;

```
                break;
```
```
            }
```
```
            dl.reverse();
```
```
            cout<<endl;
```
```
            break;
```
```
        case 8:
```
```
            exit(1);
```
```
        default:
```
```
            cout<<"Wrong choice"<<endl;
```
```
        }
```
```
    }
```
```
    return 0;
```
```
}
```
```
 
```
```
/*
```
```
 * Create Double Link List
```
```
 */
```

void double_llist::create_list(int value)

```
{
```
```
    struct node *s, *temp;
```
```
    temp = new(struct node); 
```
```
    temp->info = value;
```
```
    temp->next = NULL;
```
```
    if (start == NULL)
```
```
    {
```
```
        temp->prev = NULL;
```
```
        start = temp;
```
```
    }
```
```
    else
```
```
    {
```
```
        s = start;
```
```
        while (s->next != NULL)
```
```
            s = s->next;
```
```
        s->next = temp;
```
```
        temp->prev = s;
```
```
    }
```
```
}
```
```
 
```
```
/*
```
```
 * Insertion at the beginning
```
```
 */
```
```
void double_llist::add_begin(int value)
```
```
{
```
```
    if (start == NULL)
```
```
    {
```

        cout<<"First Create the list."<<endl;

```
        return;
```
```
    }
```
```
    struct node *temp;
```
```
    temp = new(struct node);
```
```
    temp->prev = NULL;
```
```
    temp->info = value;
```
```
    temp->next = start;
```
```
    start->prev = temp;
```
```
    start = temp;
```
```
    cout<<"Element Inserted"<<endl;
```
```
}
```
```
 
```
```
/*
```

 * Insertion of element at a particular position

```
 */
```

void double_llist::add_after(int value, int pos)

```
{
```
```
    if (start == NULL)
```
```
    {
```

        cout<<"First Create the list."<<endl;

```
        return;
```
```
    }
```
```
    struct node *tmp, *q;
```
```
    int i;
```
```
    q = start;
```
```
    for (i = 0;i < pos - 1;i++)
```
```
    {
```
```
        q = q->next;
```
```
        if (q == NULL)
```
```
        {
```

            cout<<"There are less than ";

            cout<<pos<<" elements."<<endl;

```
            return;
```
```
        }
```
```
    }
```
```
    tmp = new(struct node);
```
```
    tmp->info = value;
```
```
    if (q->next == NULL)
```
```
    {
```
```
        q->next = tmp;
```
```
        tmp->next = NULL;
```
```
        tmp->prev = q;      
```
```
    }
```
```
    else
```
```
    {
```
```
        tmp->next = q->next;
```
```
        tmp->next->prev = tmp;
```
```
        q->next = tmp;
```
```
        tmp->prev = q;
```
```
    }
```
```
    cout<<"Element Inserted"<<endl;
```
```
}
```
```
 
```
```
/*
```
```
 * Deletion of element from the list
```
```
 */
```

void double_llist::delete_element(int value)

```
{
```
```
    struct node *tmp, *q;
```
```
     /*first element deletion*/
```
```
    if (start->info == value)
```
```
    {
```
```
        tmp = start;
```
```
        start = start->next;  
```
```
        start->prev = NULL;
```
```
        cout<<"Element Deleted"<<endl;
```
```
        free(tmp);
```
```
        return;
```
```
    }
```
```
    q = start;
```
```
    while (q->next->next != NULL)
```
```
    {   
```
```
        /*Element deleted in between*/
```
```
        if (q->next->info == value)  
```
```
        {
```
```
            tmp = q->next;
```
```
            q->next = tmp->next;
```
```
            tmp->next->prev = q;
```

            cout<<"Element Deleted"<<endl;

```
            free(tmp);
```
```
            return;
```
```
        }
```
```
        q = q->next;
```
```
    }
```
```
     /*last element deleted*/
```
```
    if (q->next->info == value)    
```
```
    {   
```
```
        tmp = q->next;
```
```
        free(tmp);
```
```
        q->next = NULL;
```
```
        cout<<"Element Deleted"<<endl;
```
```
        return;
```
```
    }
```

    cout<<"Element "<<value<<" not found"<<endl;

```
}
```
```
 
```
```
/*
```
```
 * Display elements of Doubly Link List
```
```
 */
```
```
void double_llist::display_dlist()
```
```
{
```
```
    struct node *q;
```
```
    if (start == NULL)
```
```
    {
```

        cout<<"List empty,nothing to display"<<endl;

```
        return;
```
```
    }
```
```
    q = start;
```

    cout<<"The Doubly Link List is :"<<endl;

```
    while (q != NULL)
```
```
    {
```
```
        cout<<q->info<<" <-> ";
```
```
        q = q->next;
```
```
    }
```
```
    cout<<"NULL"<<endl;
```
```
}
```
```
 
```
```
/*
```

 * Number of elements in Doubly Link List

```
 */
```
```
void double_llist::count()
```
```
{       
```
```
    struct node *q = start;
```
```
    int cnt = 0;
```
```
    while (q != NULL)
```
```
    {
```
```
        q = q->next;
```
```
        cnt++;
```
```
    }
```

    cout<<"Number of elements are: "<<cnt<<endl;

```
}
```
```
 
```
```
/*
```
```
 * Reverse Doubly Link List
```
```
 */
```
```
void double_llist::reverse()
```
```
{
```
```
    struct node *p1, *p2;
```
```
    p1 = start;
```
```
    p2 = p1->next;
```
```
    p1->next = NULL;
```
```
    p1->prev = p2;
```
```
    while (p2 != NULL)
```
```
    {
```
```
        p2->prev = p2->next;
```
```
        p2->next = p1;
```
```
        p1 = p2;
```
```
        p2 = p2->prev; 
```
```
    }
```
```
    start = p1;
```
```
    cout<<"List Reversed"<<endl; 
```
```
}
```

venereology answered 2 years ago

Can you make this singular linked list to doubly linked list Create a Doubly Linked List....

Can you make this singular linked list to doubly linked list Create a Doubly Linked List. Use this to create a Sorted Linked List, Use this to create a prioritized list by use. Bring to front those links recently queried. -----link.h------ #ifndef LINK_H #define LINK_H struct Link{ int data; Link *lnkNxt; }; #endif /* LINK_H */ ----main.cpp---- //System Level Libraries #include <iostream> //I/O Library using namespace std; //Libraries compiled under std #include"Link.h" //Global Constants - Science/Math Related //Conversions, Higher Dimensions...

Using the singly linked list code as a base, create a class that implements a doubly...

Using the singly linked list code as a base, create a class that implements a doubly linked list. A doubly linked list has a Previous link so you can move backwards in the list. Be sure the class is a template class so the user can create a list with any data type. Be sure to test all the member functions in your test program. c++

9.7 LAB: Inserting an integer in descending order (doubly-linked list) Given main() and an IntNode class,...

9.7 LAB: Inserting an integer in descending order (doubly-linked list) Given main() and an IntNode class, complete the IntList class (a linked list of IntNodes) by writing the insertInDescendingOrder() method to insert new IntNodes into the IntList in descending order. Ex. If the input is: 3 4 2 5 1 6 7 9 8 -1 the output is: 9 8 7 6 5 4 3 2 1 Sortedlist.java import java.util.Scanner; public class SortedList { public static void main (String[] args)...

Develop a C++ "doubly" linked list class of your own that can hold a series of...

Develop a C++ "doubly" linked list class of your own that can hold a series of signed shorts Develop the following functionality: Develop a linked list node struct/class You can use it as a subclass like in the book (Class contained inside a class) You can use it as its own separate class Your choice Maintain a private pointer to a node class pointer (head) Constructor Initialize head pointer to null Destructor Make sure to properly delete every node in...

Using doubly linked list in c++ with class constructor: DNode(){ song = Song(); prev...

Using doubly linked list in c++ with class constructor: DNode(){ song = Song(); prev = NULL; next = NULL; } DNode(string s, string a, int lenmin, int lensec){ song = Song(s,a,lenmin,lensec); prev = NULL; next = NULL; } for each node. Write the method: void moveUp(string t); This method moves a song up one in the playlist. For instance, if you had the following: Punching in a Dream, The Naked And Famous................3:58 Harder To...

Given a doubly linked list in c++, how do I create a function that returns the...

Given a doubly linked list in c++, how do I create a function that returns the pointer to first node in the given pattern, For example, given mainList (a -> b -> c -> d) and sublist (b -> c), our function should return a Node pointer that points to first node of the sublist in the mainList. If the pattern doesn't exist in the mainList, we should return a nullptr, there are multiple of the same sublist in the mainList,...

Given a doubly linked list in c++, how do I create a function that returns the...

Given a doubly linked list in c++, how do I create a function that returns the pointer to first node in the given pattern, For example, given mainList (a -> b -> c -> d) and sublist (b -> c), our function should return a Node pointer that points to first node of the sublist in the mainList. If the pattern doesn't exist in the mainList, we should return a nullptr, there are multiple of the same sublist in the mainList,...

A circular doubly-linked list .(a) In a circular doubly-linked list, there is no front or end;...

A circular doubly-linked list .(a) In a circular doubly-linked list, there is no front or end; the nodes form a full circle. Instead of keeping track of the node at the front, we keep track of a current node instead. Write a class for a circular doubly-linked list using the attached Job class as your node objects. It should have: • A private instance variable for the current node • A getCurrent() method that returns a reference to the current...

TITLE Updating Accounts Using Doubly Linked List TOPICS Doubly Linked List DESCRIPTION General Write a program...

TITLE Updating Accounts Using Doubly Linked List TOPICS Doubly Linked List DESCRIPTION General Write a program that will update bank accounts stored in a master file using updates from a transaction file. The program will maintain accounts using a doubly linked list. The input data will consist of two text files: a master file and a transaction file. See data in Test section below. The master file will contain only the current account data. For each account, it will contain account...

Write the following algorithms for a Doubly Linked List Inserting an item

Write the following algorithms for a Doubly Linked List Inserting an item [7] Deleting an item [7] Question two Take a queue containing numbers 10, 15, 5, 25, 30 in which 30 has been inserted first. After performing the following operations, what would be the contents of the queue? Delete two elements [2] Insert 7 and then 20 [2] Delete an element [2]

Question

Write in C++: create a Doubly Linked List class that holds a struct with an integer...

Solutions

Expert Solution

Related Solutions

Can you make this singular linked list to doubly linked list Create a Doubly Linked List....

Using the singly linked list code as a base, create a class that implements a doubly...

9.7 LAB: Inserting an integer in descending order (doubly-linked list) Given main() and an IntNode class,...

Develop a C++ "doubly" linked list class of your own that can hold a series of...

Using doubly linked list in c++ with class constructor: DNode(){ song = Song(); prev...

Given a doubly linked list in c++, how do I create a function that returns the...

Given a doubly linked list in c++, how do I create a function that returns the...

A circular doubly-linked list .(a) In a circular doubly-linked list, there is no front or end;...

TITLE Updating Accounts Using Doubly Linked List TOPICS Doubly Linked List DESCRIPTION General Write a program...

Write the following algorithms for a Doubly Linked List Inserting an item