List Data Structure Using Doubly Linked List In Data Structure Using C++

on

Data Structure Using C++

List Data Structure

List Using Doubly Linked List

class node
{
 private:
  int data;
  node *next;
  node *prev;
 public:
  node(int d);
  void set(int d);
  int get ();
  void setNext (node *);
  node* getNext();
  void setPrev (node *);
  node* getPrev();
  void showData();
};
node::node(int d)
{
 data=d;
 next=NULL;
 prev=NULL;
}
void node::set(int d)
{
 data=d;
}
int node::get()
{
 return data;
}
void node::setNext(node* n)
{
 next=n;
}
node* node::getNext()
{
 return next;
}
void node::setPrev(node* p)
{
 prev=p;
}
node* node::getPrev()
{
 return prev;
}
void node::showData()
{
 cout<<get()<<"\t";
}


class LinkedList{
 private:
  node* headNode;
  node* currentNode;
  int size;
 public:
  LinkedList();
  void start();
  void next();
  void back();
  int get();
  int length();
  void add(int d);
  void update(int d);
  void remove();
  void find(int d);
  void showList();
};
LinkedList::LinkedList(){
 headNode=NULL;
 currentNode=NULL;
 size=0;
}
void LinkedList::start(){
 currentNode=headNode; 
}
void LinkedList::next(){
 if(currentNode->getNext()!=NULL){
  currentNode=currentNode->getNext();
 }
}
void LinkedList::back(){
 if(currentNode->getPrev()!=NULL){
  currentNode=currentNode->getPrev();
 }
}
int LinkedList::get(){
 if(currentNode!=NULL){
  return currentNode->get();
 }
}
int LinkedList::length() 
{  
 return size;  
}
void LinkedList::add(int d) 
{ 
    node* newNode=new node(d); 
    if(size==0){
     currentNode=newNode;
     headNode=newNode;
 }
 else{
  node* next;
  node* prev;
  prev=currentNode;
  next=currentNode->getNext();
  newNode->setNext(next);
  newNode->setPrev(prev);
  if(newNode->getNext()!=NULL)
  {
   next->setPrev(newNode);
  }
  prev->setNext(newNode);
  currentNode=newNode;
 }
    size ++;
}
void LinkedList::update(int d){
 if(currentNode!=NULL){
  currentNode->set(d);
 }
}
void LinkedList::remove() 
{
 if(size>0)
 {
  if(currentNode==headNode){   
   currentNode=currentNode->getNext();
   currentNode->setPrev(NULL);
   headNode=currentNode;  
   size--;
  }else{ 
   node* prev;
   node* next;
   prev=currentNode->getPrev();
   next=currentNode->getNext();
   if(next!=NULL){
    next->setPrev(prev);
   }
   prev->setNext(next);
   currentNode=prev;
   size--;
  }
 }
 else
 {
  cout<<"List is empty";
 }
}
void LinkedList::find(int d){
 node* ptr;
 ptr=headNode;
 bool found=false;
 do{
  if(ptr->get()==d)
  {
   found=true;
   break;
  }
  ptr=ptr->getNext();
 }while(ptr!=NULL);
 if(found==true){  
  cout<<"Value is found."<<endl;
 }else{
  cout<<"Value is not found."<<endl;
 }
}
void LinkedList::showList(){
 node* ptr;
 ptr=headNode;
 do{
  ptr->showData();
  ptr=ptr->getNext();
 }while(ptr!=NULL);
 cout<<endl;
}
int main(){
 LinkedList list;  
 list.add(5);
 list.add(7);
 list.add(1);
 list.add(6);
 list.showList();
 list.remove();
 list.update(3);
 list.showList();
 list.start();
 list.add(9);
 list.showList();
 list.start();
 list.remove();
 list.showList();
 list.find(9);
 list.update(3);
 list.showList();
}

Let me know in the comment section if you have any question.

Previous Post:
List Data Structure Using Singly Linked List In C++

Comments

Post a Comment