CPP

doubly linked list c++ code

/*
* Doubly linked list implementation in c++.
* operations:
* 1-> Insert at head.
* 2-> print forward.
* 3-> print reverse order.
*/
#include<iostream>
using namespace std;
struct node
{
	int data;
	node* next;
	node* prev;
};
class d_list
{
private:
	node* head;
	node* GetNewNode(int n)
	{
		node* newNode = new node();
		newNode->data = n;
		newNode->next = NULL;
		newNode->prev = NULL;
		return newNode;
	}
public:
	d_list()
	{
		head = NULL;
	}
	void InsertAtHead(int n)
	{
		node* temp = GetNewNode(n);
		if (head == NULL)
		{
			head = temp;
			return;
		}
		head->prev = temp;
		temp->next = head;
		head = temp;
	}
	void print()
	{
		node* t = head;
		cout << "Forward: ";
		while (t!=NULL)
		{
			cout << t->data << " ";
			t = t->next;
		}
		cout << "
";
	}
	void print_reverse()
	{
		node* t = head;
		while (t->next != NULL)
		{
			t = t->next;
		}
		//reverse
		cout << "reverse: ";
		while (t != NULL)
		{
			cout << t->data << " ";
			t = t->prev;
		}
		cout << "
";
	}
};

int main()
{
	d_list l;     //object from class doubly list
	l.InsertAtHead(1);
	l.InsertAtHead(2);    //function insert at beginning
	l.InsertAtHead(3);
	l.print();             //List should print: 3 2 1
	l.print_reverse();     //List should print: 1 2 3
	return 0;
}

doubly linked list in cpp

#include<iostream>
using namespace std;
class node{
 private:
    int data;
    node *next;
    node *prev;
     public:
        void insertData();
        void printData();
};
node *head=0;
void node::insertData()
{
    int d;
    head=new node();
    cout<<"Enter data : ";
    cin>>d;
    head->prev=0;
    head->data=d;
    head->next=0;
    node *top;
    top=head;
    node *newnode;
    int c=0;
    cout<<"Do you want to continue if yes press 1 else press : ";
    cin>>c;
    while (c==1)
    {
        newnode=new node();
        cout<<"Enter data : ";
        cin>>newnode->data;
        newnode->next=0;
        newnode->prev=0;
        top->next=newnode;
        top=top->next;
        cout<<"Do you want to continue if yes press 1 and press 2 : ";
        cin>>c;
    }
}

void node::printData()
{
    node *top;
    top=head;
    while(top!=0)
    {
    cout<<top->data<<" ";
    top=top->next;
    }
}

int main()
{
    node obj;
    obj.insertData();
    obj.printData();
}

c++ doubly linked list

#include <iostream>
#include <list>

// For help in printing lists
std::ostream& operator<<(std::ostream& ostr, const std::list<int>& list) {
    for (const auto &i : list) {
        ostr << ' ' << i;
    }
    return ostr;
}


int main() {

    std::list<int> list1 = { 5,9,1,3,3 };
    std::list<int> list2 = { 8,7,2,3,4,4 };

    list1.sort();
    list2.sort();
    std::cout << "list1:  " << list1 << '
';
    std::cout << "list2:  " << list2 << '
';
    list1.merge(list2);
    std::cout << "merged: " << list1 << '
';

    return 0;
}

doubly linked list code in c++

// A complete working C++ program to
// demonstrate all insertion methods
#include <bits/stdc++.h>
using namespace std;
 
// A linked list node
class Node
{
    public:
    int data;
    Node* next;
    Node* prev;
};
 
/* Given a reference (pointer to pointer)
to the head of a list
and an int, inserts a new node on the
front of the list. */
void push(Node** head_ref, int new_data)
{
    /* 1. allocate node */
    Node* new_node = new Node();
 
    /* 2. put in the data */
    new_node->data = new_data;
 
    /* 3. Make next of new node as head
    and previous as NULL */
    new_node->next = (*head_ref);
    new_node->prev = NULL;
 
    /* 4. change prev of head node to new node */
    if ((*head_ref) != NULL)
        (*head_ref)->prev = new_node;
 
    /* 5. move the head to point to the new node */
    (*head_ref) = new_node;
}
 
/* Given a node as prev_node, insert
a new node after the given node */
void insertAfter(Node* prev_node, int new_data)
{
    /*1. check if the given prev_node is NULL */
    if (prev_node == NULL)
    {
        cout<<"the given previous node cannot be NULL";
        return;
    }
 
    /* 2. allocate new node */
    Node* new_node = new Node();
 
    /* 3. put in the data */
    new_node->data = new_data;
 
    /* 4. Make next of new node as next of prev_node */
    new_node->next = prev_node->next;
 
    /* 5. Make the next of prev_node as new_node */
    prev_node->next = new_node;
 
    /* 6. Make prev_node as previous of new_node */
    new_node->prev = prev_node;
 
    /* 7. Change previous of new_node's next node */
    if (new_node->next != NULL)
        new_node->next->prev = new_node;
}
 
/* Given a reference (pointer to pointer) to the head
of a DLL and an int, appends a new node at the end */
void append(Node** head_ref, int new_data)
{
    /* 1. allocate node */
    Node* new_node = new Node();
 
    Node* last = *head_ref; /* used in step 5*/
 
    /* 2. put in the data */
    new_node->data = new_data;
 
    /* 3. This new node is going to be the last node, so
        make next of it as NULL*/
    new_node->next = NULL;
 
    /* 4. If the Linked List is empty, then make the new
        node as head */
    if (*head_ref == NULL)
    {
        new_node->prev = NULL;
        *head_ref = new_node;
        return;
    }
 
    /* 5. Else traverse till the last node */
    while (last->next != NULL)
        last = last->next;
 
    /* 6. Change the next of last node */
    last->next = new_node;
 
    /* 7. Make last node as previous of new node */
    new_node->prev = last;
 
    return;
}
 
// This function prints contents of
// linked list starting from the given node
void printList(Node* node)
{
    Node* last;
    cout<<"
Traversal in forward direction 
";
    while (node != NULL)
    {
        cout<<" "<<node->data<<" ";
        last = node;
        node = node->next;
    }
 
    cout<<"
Traversal in reverse direction 
";
    while (last != NULL)
    {
        cout<<" "<<last->data<<" ";
        last = last->prev;
    }
}
 
/* Driver program to test above functions*/
int main()
{
    /* Start with the empty list */
    Node* head = NULL;
 
    // Insert 6. So linked list becomes 6->NULL
    append(&head, 6);
 
    // Insert 7 at the beginning. So
    // linked list becomes 7->6->NULL
    push(&head, 7);
 
    // Insert 1 at the beginning. So
    // linked list becomes 1->7->6->NULL
    push(&head, 1);
 
    // Insert 4 at the end. So linked
    // list becomes 1->7->6->4->NULL
    append(&head, 4);
 
    // Insert 8, after 7. So linked
    // list becomes 1->7->8->6->4->NULL
    insertAfter(head->next, 8);
 
    cout << "Created DLL is: ";
    printList(head);
 
    return 0;
}
 
// This is code is contributed by rathbhupendra