# Circular Doubly Linked List - Delete first node by key

In this method, first node in the circular doubly linked list with specified key (value) is deleted. For example - if the given list is 10->20->30->10->20 and the first occurrence of 20 is deleted, the list becomes 10->30->10->20.

The function pop_first is created for this purpose. It is a 4-step process.

```void pop_first(int key) {

//1. if head is not null, create three nodes- temp,
//   nodeToDelete and lastNode - to traverse and to
//   track the last node and node to delete
Node* lastNode;

//2. if the value store at head is the key and head
//   is the only element in the list, make it null
if(temp->data == key) {
} else {

//3. if the value store at head is the key and list
free(nodeToDelete);
}
} else {

//4. Else, traverse to the node previous to the
if(temp->next->data == key) {
nodeToDelete = temp->next;
temp->next = temp->next->next;
temp->next->prev = temp;
free(nodeToDelete);
break;
}
temp = temp->next;
}
}
}
}
```
```void pop_first(struct Node** head_ref, int key) {

//1. if head is not null, create three nodes- temp,
//   nodeToDelete and lastNode - to traverse and to
//   track the last node and node to delete
struct Node* lastNode;

//2. if the value store at head is the key and head
//   is the only element in the list, make it null
if(temp->data == key) {
} else {

//3. if the value store at head is the key and list
free(nodeToDelete);
}
} else {

//4. Else, traverse to the node previous to the
if(temp->next->data == key) {
nodeToDelete = temp->next;
temp->next = temp->next->next;
temp->next->prev = temp;
free(nodeToDelete);
break;
}
temp = temp->next;
}
}
}
}
```
```def pop_first(self, key):

#1. if head is not null, create two nodes- temp,
#   nodeToDelete - to traverse and to
#   track the node to delete

#2. if the value store at head is the key and head
#   is the only element in the list, make it null
if(temp.data == key):
else:

#3. if the value store at head is the key and list
nodeToDelete = None
else:

#4. Else, traverse to the node previous to the
if(temp.next.data == key):
nodeToDelete = temp.next
temp.next = temp.next.next
temp.next.prev = temp
nodeToDelete = None
break
temp = temp.next
```
```void pop_first(int key) {

//1. if head is not null, create three nodes- temp,
//   nodeToDelete and lastNode - to traverse and to
//   track the last node and node to delete
Node lastNode = new Node();

//2. if the value store at head is the key and head
//   is the only element in the list, make it null
if(temp.data == key) {
} else {

//3. if the value store at head is the key and list
nodeToDelete = null;
}
} else {

//4. Else, traverse to the node previous to the
if(temp.next.data == key) {
nodeToDelete = temp.next;
temp.next = temp.next.next;
temp.next.prev = temp;
nodeToDelete = null;
break;
}
temp = temp.next;
}
}
}
}
```
```public void pop_first(int key) {

//1. if head is not null, create three nodes- temp,
//   nodeToDelete and lastNode - to traverse and to
//   track the last node and node to delete
Node lastNode = new Node();

//2. if the value store at head is the key and head
//   is the only element in the list, make it null
if(temp.data == key) {
} else {

//3. if the value store at head is the key and list
nodeToDelete = null;
}
} else {

//4. Else, traverse to the node previous to the
if(temp.next.data == key) {
nodeToDelete = temp.next;
temp.next = temp.next.next;
temp.next.prev = temp;
nodeToDelete = null;
break;
}
temp = temp.next;
}
}
}
}
```
```public function pop_first(\$key) {

//1. if head is not null, create three nodes- temp,
//   nodeToDelete and lastNode - to traverse and to
//   track the last node and node to delete
\$lastNode = new Node();

//2. if the value store at head is the key and head
//   is the only element in the list, make it null
if(\$temp->data == \$key) {
} else {

//3. if the value store at head is the key and list
\$nodeToDelete = null;
}
} else {

//4. Else, traverse to the node previous to the
if(\$temp->next->data == \$key) {
\$nodeToDelete = \$temp->next;
\$temp->next = \$temp->next->next;
\$temp->next->prev = \$temp;
\$nodeToDelete = null;
break;
}
\$temp = \$temp->next;
}
}
}
}
```

The below is a complete program that uses above discussed concept to delete first occurrence of the specified key (if exists) of the circular doubly linked list.

```#include <iostream>
using namespace std;

//node structure
struct Node {
int data;
Node* next;
Node* prev;
};

private:
public:
}

//Add new element at the end of the list
void push_back(int newElement) {
Node* newNode = new Node();
newNode->data = newElement;
newNode->next = NULL;
newNode->prev = NULL;
} else {
temp = temp->next;
temp->next = newNode;
newNode->prev = temp;
}
}

//Delete first node by key
void pop_first(int key) {
Node* lastNode;
if(temp->data == key) {
} else {
free(nodeToDelete);
}
} else {
if(temp->next->data == key) {
nodeToDelete = temp->next;
temp->next = temp->next->next;
temp->next->prev = temp;
free(nodeToDelete);
break;
}
temp = temp->next;
}
}
}
}

//display the content of the list
void PrintList() {
if(temp != NULL) {
cout<<"The list contains: ";
while(true) {
cout<<temp->data<<" ";
temp = temp->next;
break;
}
cout<<endl;
} else {
cout<<"The list is empty.\n";
}
}
};

// test the code
int main() {

//Add five elements at the end of the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(10);
MyList.push_back(20);
MyList.PrintList();

//Delete first occurrence of 20
MyList.pop_first(20);
MyList.PrintList();

return 0;
}
```

The above code will give the following output:

```The list contains: 10 20 30 10 20
The list contains: 10 30 10 20
```
```#include <stdio.h>
#include <stdlib.h>

//node structure
struct Node {
int data;
struct Node* next;
struct Node* prev;
};

//Add new element at the end of the list
void push_back(struct Node** head_ref, int newElement) {
struct Node *newNode, *temp;
newNode = (struct Node*)malloc(sizeof(struct Node));
newNode->data = newElement;
newNode->next = NULL;
newNode->prev = NULL;
} else {
temp = temp->next;
}
temp->next = newNode;
newNode->prev = temp;
}
}

//Delete first node by key
void pop_first(struct Node** head_ref, int key) {
struct Node* lastNode;
if(temp->data == key) {
} else {
free(nodeToDelete);
}
} else {
if(temp->next->data == key) {
nodeToDelete = temp->next;
temp->next = temp->next->next;
temp->next->prev = temp;
free(nodeToDelete);
break;
}
temp = temp->next;
}
}
}
}

//display the content of the list
printf("The list contains: ");
while (1) {
printf("%i ",temp->data);
temp = temp->next;
break;
}
printf("\n");
} else {
printf("The list is empty.\n");
}
}

// test the code
int main() {
struct Node* MyList = NULL;

//Add five elements at the end of the list.
push_back(&MyList, 10);
push_back(&MyList, 20);
push_back(&MyList, 30);
push_back(&MyList, 10);
push_back(&MyList, 20);
PrintList(MyList);

//Delete first occurrence of 20
pop_first(&MyList, 20);
PrintList(MyList);

return 0;
}
```

The above code will give the following output:

```The list contains: 10 20 30 10 20
The list contains: 10 30 10 20
```
```# node structure
class Node:
def __init__(self, data):
self.data = data
self.next = None
self.prev = None

def __init__(self):

#Add new element at the end of the list
def push_back(self, newElement):
newNode = Node(newElement)
return
else:
temp = temp.next
temp.next = newNode
newNode.prev = temp

#Delete first node by key
def pop_first(self, key):
if(temp.data == key):
else:
nodeToDelete = None
else:
if(temp.next.data == key):
nodeToDelete = temp.next
temp.next = temp.next.next
temp.next.prev = temp
nodeToDelete = None
break
temp = temp.next

#display the content of the list
def PrintList(self):
if(temp != None):
print("The list contains:", end=" ")
while (True):
print(temp.data, end=" ")
temp = temp.next
break
print()
else:
print("The list is empty.")

# test the code

#Add five elements at the end of the list.
MyList.push_back(10)
MyList.push_back(20)
MyList.push_back(30)
MyList.push_back(10)
MyList.push_back(20)
MyList.PrintList()

#Delete first occurrence of 20
MyList.pop_first(20)
MyList.PrintList()
```

The above code will give the following output:

```The list contains: 10 20 30 10 20
The list contains: 10 30 10 20
```
```//node structure
class Node {
int data;
Node next;
Node prev;
};

}

//Add new element at the end of the list
void push_back(int newElement) {
Node newNode = new Node();
newNode.data = newElement;
newNode.next = null;
newNode.next = null;
} else {
Node temp = new Node();
temp = temp.next;
temp.next = newNode;
newNode.prev = temp;
}
}

//Delete first node by key
void pop_first(int key) {
Node lastNode = new Node();
if(temp.data == key) {
} else {
nodeToDelete = null;
}
} else {
if(temp.next.data == key) {
nodeToDelete = temp.next;
temp.next = temp.next.next;
temp.next.prev = temp;
nodeToDelete = null;
break;
}
temp = temp.next;
}
}
}
}

//display the content of the list
void PrintList() {
Node temp = new Node();
if(temp != null) {
System.out.print("The list contains: ");
while(true) {
System.out.print(temp.data + " ");
temp = temp.next;
break;
}
System.out.println();
} else {
System.out.println("The list is empty.");
}
}
};

// test the code
public class Implementation {
public static void main(String[] args) {

//Add five elements at the end of the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(10);
MyList.push_back(20);
MyList.PrintList();

//Delete first occurrence of 20
MyList.pop_first(20);
MyList.PrintList();
}
}
```

The above code will give the following output:

```The list contains: 10 20 30 10 20
The list contains: 10 30 10 20
```
```using System;

//node structure
class Node {
public int data;
public Node next;
public Node prev;
};

}

//Add new element at the end of the list
public void push_back(int newElement) {
Node newNode = new Node();
newNode.data = newElement;
newNode.next = null;
newNode.prev = null;
} else {
Node temp = new Node();
temp = temp.next;
temp.next = newNode;
newNode.prev = temp;
}
}

//Delete first node by key
public void pop_first(int key) {
Node lastNode = new Node();
if(temp.data == key) {
} else {
nodeToDelete = null;
}
} else {
if(temp.next.data == key) {
nodeToDelete = temp.next;
temp.next = temp.next.next;
temp.next.prev = temp;
nodeToDelete = null;
break;
}
temp = temp.next;
}
}
}
}

//display the content of the list
public void PrintList() {
Node temp = new Node();
if(temp != null) {
Console.Write("The list contains: ");
while(true) {
Console.Write(temp.data + " ");
temp = temp.next;
break;
}
Console.WriteLine();
} else {
Console.WriteLine("The list is empty.");
}
}
};

// test the code
class Implementation {
static void Main(string[] args) {

//Add five elements at the end of the list.
MyList.push_back(10);
MyList.push_back(20);
MyList.push_back(30);
MyList.push_back(10);
MyList.push_back(20);
MyList.PrintList();

//Delete first occurrence of 20
MyList.pop_first(20);
MyList.PrintList();
}
}
```

The above code will give the following output:

```The list contains: 10 20 30 10 20
The list contains: 10 30 10 20
```
```<?php
//node structure
class Node {
public \$data;
public \$next;
public \$prev;
}

public function __construct(){
}

//Add new element at the end of the list
public function push_back(\$newElement) {
\$newNode = new Node();
\$newNode->data = \$newElement;
\$newNode->next = null;
\$newNode->prev = null;
} else {
\$temp = new Node();
\$temp = \$temp->next;
}
\$temp->next = \$newNode;
\$newNode->prev = \$temp;
}
}

//Delete first node by key
public function pop_first(\$key) {
\$lastNode = new Node();
if(\$temp->data == \$key) {
} else {
\$nodeToDelete = null;
}
} else {
if(\$temp->next->data == \$key) {
\$nodeToDelete = \$temp->next;
\$temp->next = \$temp->next->next;
\$temp->next->prev = \$temp;
\$nodeToDelete = null;
break;
}
\$temp = \$temp->next;
}
}
}
}

//display the content of the list
public function PrintList() {
\$temp = new Node();
if(\$temp != null) {
echo "The list contains: ";
while(true) {
echo \$temp->data." ";
\$temp = \$temp->next;
break;
}
echo "\n";
} else {
echo "The list is empty.\n";
}
}
};

// test the code

//Add five elements at the end of the list.
\$MyList->push_back(10);
\$MyList->push_back(20);
\$MyList->push_back(30);
\$MyList->push_back(10);
\$MyList->push_back(20);
\$MyList->PrintList();

//Delete first occurrence of 20
\$MyList->pop_first(20);
\$MyList->PrintList();
?>
```

The above code will give the following output:

```The list contains: 10 20 30 10 20
The list contains: 10 30 10 20
```

5