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.

Solutions

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 1 year ago

Next > < Previous

Related Solutions

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,...

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]

Python class DLLNode: """ Class representing a node in the doubly linked list implemented below. """...

Python class DLLNode: """ Class representing a node in the doubly linked list implemented below. """ def __init__(self, value, next=None, prev=None): """ Constructor @attribute value: the value to give this node @attribute next: the next node for this node @attribute prev: the previous node for this node """ self.__next = next self.__prev = prev self.__value = value def __repr__(self): return str(self.__value) def __str__(self): return str(self.__value) def get_value(self): """ Getter for value :return: the value of the node """ return self.__value...

Using C++, you will create a program, where you will create two doubly linked lists. These...

Using C++, you will create a program, where you will create two doubly linked lists. These doubly linked lists will contain integers within them. Using the numbers in both of these linked lists, you add the numbers together, and insert the addition of the two numbers into a singly linked list. the input can be from the user or you just write the input. for example, if one number in the doubly linked list is 817 and in the other...

so the assigment is is a data strucutre using c++ to make a doubly linked list...

so the assigment is is a data strucutre using c++ to make a doubly linked list that will be able to do math mostly addition and multiplication, subratction and division is extra and would be nice. so the program is going to to open files and read them via a argumentmanager.h in a linux server try not to worry to much about this part just getting the program to work. i was able to complete part of the given code...

a) Write C code using a struct to hold student information: integer id integer number of...

a) Write C code using a struct to hold student information: integer id integer number of hours taken integer number of hours passed double gpa b) create a variable of the type in #25 and initialize it with some data.

Subjects