/*
* 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;
}#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();
}#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;
}// 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