The complete code of single linked list, circular linked list, two-way linked list and Linux kernel "shared" double linked list is attached at the end of the article

catalogue

1, Detailed explanation of linked list principle

2, Implementation of single linked list algorithm

2.1 concept of single linked list

2.3.1 forward interpolation

2.3.2 tail interpolation method

2.3.3 insertion at any position

2.5 obtaining elements from single linked list

2.6 single linked list lookup elements

2.7 deleting elements from single linked list

2.8 destruction of single linked list

3, Implementation of circular linked list algorithm

Joseph problem

4, Implementation of bidirectional linked list algorithm

4.1 initialization of bidirectional linked list

4.2.1 forward interpolation

4.2.2 tail interpolation method

4.2.3 insertion at any position

4.3 two way linked list traversal

4.4 obtaining elements from bidirectional linked list

4.5 deleting elements from a two-way linked list

4.6 destruction of two-way linked list

5, Linux kernel "shared" bidirectional linked list

Complete code of circular linked list

Two way linked list complete code

# 1, Detailed explanation of linked list principle

A linked list is a chain storage method of a linear list. Logically, the storage locations of adjacent data in the computer do not have to be adjacent
How to express logical adjacency? You can attach a pointer field to each element, pointing to the storage bit of the next element
Set. As shown in the figure: As can be seen from the figure, each node contains two fields: data field and pointer field. The pointer field stores the address of the next node,
Therefore, the type pointed to by the pointer is also a node type.

I each node consists of data field and pointer field
The II pointer field points to the memory address of the next node

```Its structure definition
ElemType data;

# 2, Implementation of single linked list algorithm

## 2.1 concept of single linked list The nodes of the linked list all point to the next node in one direction, forming a one-way access data chain ## 2.2 single linked list initialization

```typedef struct _LinkNode {
int data; //Data field of node
struct _LinkNode *next; //Pointer field of node

if(!L)return false; //Failed to generate node
L->next=NULL; //The pointer field of the header node is set to null
return true;
}``` ### 2.3.1 forward interpolation

```//Forward interpolation
if(!L || !node ) return false;
node->next = L->next;
L->next = node;
return true;
}``` ### 2.3.2 tail interpolation method

```//Tail interpolation
if(!L || !node ) return false;
//Last node found
last = L;
while(last->next) last=last->next;
//The new node is linked to the tail
node->next = NULL;
last->next = node;
return true;
}``` ### 2.3.3 insertion at any position

```//Arbitrary position interpolation
//Insert a new node with a value of e at the ith position in the single linked list L of the leading node
int j;
p=L;
j=0;
while (p&&j<i-1){ //Find the i-1 node, and p points to it
p=p->next;
j++;
}
if (!p || j>i-1){//i > n+1 or i < 1
return false;
}
s->data=e; //Set the data field of the new node to e
s->next=p->next; //Point the pointer field of the new node to the node ai
p->next=s; //Point the pointer field of node p to node s
return true;
}``` ## 2.4 single linked list traversal

```void LinkPrint(LinkList* &L) {//Output of single linked list
p=L->next;
while (p){
cout <<p->data <<"\t";
p=p->next;
}
cout<<endl;
}```

## 2.5 obtaining elements from single linked list

```bool Link_GetElem(LinkList* &L, int i, int &e){//Value of single linked list
//Find the ith element in the single linked list L of the leading node
//Record the value of the ith data element in L with e
int j;
p=L->next;//p points to the first node,
j=1; //j is the counter
while (j<i && p){ //Scan the chain domain backward until p points to the ith element or p is empty
p=p->next; //p points to the next node
j++; //Counter j is incremented by 1 accordingly
}
if (!p || j>i){
return false; //Illegal i value i > n or i < = 0
}
e=p->data; //Take the data field of the ith node
return true;
}```

## 2.6 single linked list lookup elements

```bool Link_FindElem(LinkList *L, int e){ //Find by value
//Find the element with value e in the single linked list L of the leading node
p=L->next;
while (p && p->data!=e){//Scan the chain domain backward until p is empty or the data domain of the node referred to by p is equal to e
p=p->next; //p points to the next node
}
if(!p)return false; //Lookup failed. p is NULL
return true;
}```

## 2.7 deleting elements from single linked list

```bool LinkDelete(LinkList* &L, int i){ //Deletion of single linked list
//In the single linked list L of the leading node, delete the ith position
int j;
p=L;
j=0;
while((p->next)&&(j<i-1)){ //Find the i-1 node, and p points to it
p=p->next;
j++;
}
if (!(p->next)||(j>i-1))//When I > n or I < 1, the deletion position is unreasonable
return false;
p->next=q->next; //Change the pointer field of the precursor node of the deleted node
delete q; //Free up space for deleted nodes
return true;
}```

## 2.8 destruction of single linked list

```void LinkDestroy(LinkList* &L) {//Destruction of single linked list
//Define the temporary node p to point to the header node
while(p){
L=L->next; //L points to the next node
cout<<"Delete element: "<<p->data<<endl;
delete p; //Delete current node
p=L; //p move to next node
}
}```

Complete code implementation:

# 3, Implementation of circular linked list algorithm

## Joseph problem

There are 10 children in numbered order 1, 2,..., 10 circle clockwise. Starting from No. 1, clockwise 1, 2,..., 9. Those who report 9 are listed (obviously, the first circle is numbered 9).
What is the number of the last person out of the circle? What is the number of the fifth person out of the circle?  The complete code of circular linked list is attached at the end of the article~

# 4, Implementation of bidirectional linked list algorithm

In addition to storing its own data, each node in the single linked list also stores the address of the next node, so you can easily access the next node and subsequent nodes, but you can't go back if you want to access the previous node. For example, when deleting node p, first find its previous node q, and then delete node p. the one-way linked list can only go back, not forward. What if you need to move forward?
You can attach two pointer fields to each element based on the single linked list, one to store the address of the previous element and the other to store the address of the next element. This kind of linked list is called bidirectional linked list. ```Its structure definition:
int data; //Data field of node
struct _LinkNode *next; //Pointer field of the next node
struct _LinkNode *prev; //Pointer field of the previous node

## 4.1 initialization of bidirectional linked list

```typedef struct _DoubleLinkNode {
int data; //Data field of node
struct _DoubleLinkNode* next; //Pointer field of the next node
struct _DoubleLinkNode* prev; //Pointer field of the previous node

L = new DbLinkNode; //Generate a new node as the head node, and point to the head node with the head pointer L
if (!L)return false; //Failed to generate node
L->next = NULL; //The next pointer field of the header node is null
L->prev = NULL; //The pointer field of the header node is set to null
L->data = -1;
return true;
}```

### 4.2.1 forward interpolation

```//Forward interpolation
if (!L || !node) return false;
if (L->next == NULL) {
node->next = NULL;
node->prev = L; //The new node prev pointer points to the header node
L->next = node; //The next pointer of the header node points to the new node
}
else {
L->next->prev = node; //The prev of the second node points to the new node
node->next = L->next; //The new node next pointer points to the second node
node->prev = L; //The new node prev pointer points to the header node
L->next = node; //The next pointer of the header node points to the new node to complete the insertion
}
return true;
}``` ### 4.2.2 tail interpolation method

```//Tail interpolation
if (!L || !node) return false;
last = L;
while (last->next) last = last->next;
node->next = NULL;
node->prev = last;
return true;
}``` ### 4.2.3 insertion at any position

```//Insert at specified location
if (!L || !L->next) return false;
if (i < 1) return false;
int j = 0;
p = L;
while (p && j < i) {//Find the node with position i, and p points to the node
p = p->next;
j++;
}
if (!p || j != i) {
cout << "Node does not exist:" << i << endl;
return false;
}
cout << "p: " << p << endl;
s = new DbLinkNode;//Generate new node
s->data = e;
s->next = p;
s->prev = p->prev;
p->prev->next = s;
p->prev = s;
return true;
}```

## 4.3 two way linked list traversal

```//Traversal output of bidirectional linked list
if (!L) {
cout << "The linked list is empty." << endl;
return;
}
p = L;
while (p->next) {
cout << p->next->data << "\t";
p = p->next;
}
//Reverse printing
cout << endl << "Reverse printing" << endl;
while (p) {
cout << p->data << "\t";
p = p->prev;
}
cout << endl;
}```

## 4.4 obtaining elements from bidirectional linked list

```bool DbLink_GetElem(DbLinkList*& L, int i, int& e){//Value of bidirectional linked list
//Find the ith element in the two-way linked list L of the leading node
//Record the value of the ith data element in L with e
int index;
if (!L || !L->next) return false;
p = L->next;
index = 1;
while (p && index < i) {//Scan the list backward until p points to the ith element or p is empty
p = p->next; //p points to the next node
index++; //The counter index is incremented by 1 accordingly
}
if (!p || index > i) {
return false; //Illegal value of i, i > n or i < = 0
}
e = p->data;
return true;
}```

## 4.5 deleting elements from a two-way linked list

```//Delete anywhere
{
int index = 0;
if (!L || !L->next) {
cout << "The two-way linked list is empty!" << endl;
return false;
}
if (i < 1) return false; //You cannot delete a header node
p = L;
while (p && index < i) {
p = p->next;
index++;
}
if (!p) { //Failure is returned when the node does not exist
return false;
}
p->prev->next = p->next; //Change the next pointer field of the predecessor node of the deleted node
if (p->next) {
p->next->prev = p->prev; //Change the prev pointer field of the successor node after deleting the node
}
delete p; //Free up space for deleted nodes
return true;
}```

## 4.6 destruction of two-way linked list

```void DbLink_Destroy(DbLinkList*& L){ //Destruction of bidirectional linked list
//Define the temporary node p to point to the header node
cout << "Destroy linked list!" << endl;
while (p) {
L = L->next;//L points to the next node
cout << "Delete element: " << p->data << endl;
delete p; //Delete current node
p = L; //p move to next node
}
}```

# 5, Linux kernel "shared" bidirectional linked list

In the linux kernel, a large number of data structures need to use two-way linked lists, such as processes, files, modules, pages and so on. If we adopt the traditional implementation of two-way linked list, we need to maintain their own linked list for these data structures, and design operation functions such as insert and delete for each linked list. Because the next and prev pointers used to maintain the linked list point to the corresponding types of objects, the linked list operation function of one data structure cannot be used to operate the linked list of other data structures.
For example, we need to define the linked list structure of stars and web server timeout respectively:

```one． web Linked list structure of server timeout
typedef struct {
int fd ;
time_t timeout; // Use the timestamp of the timeout time
}ConnTimeout;

ConnTimeout conn;
}

two．Linked list structure of bright starry sky
typedef struct {
int x; //x coordinate of the star
int y; //y coordinates of stars
enum STATUS stat; //state
int step; //Interval per jump
int color; //The color of stars
}STAR;

STAR star;
}```

Is there a way for multiple linked lists to share the same set of linked lists? See the figure below:  ```typedef struct _DoubleLinkNode {
struct _DoubleLinkNode *next; //Pointer field of the next node
struct _DoubleLinkNode *prev; //Pointer field of the previous node

typedef struct {
int fd ;
time_t timeout; // Use the timestamp of the timeout time
}ConnTimeout;``` ```typedef struct {
int x; //x coordinate of the star
int y; //y coordinates of stars
enum STATUS stat; //state
int step; //Interval per jump
int color; //The color of stars
}STAR;```

Key points:
offsetof can be used to deduce the position of structure variable according to the address of linked list node in structure
For example:

```typedef struct {
int fd ;
time_t timeout; // Use the timestamp of the timeout time
}ConnTimeout;

//Access the data hosted by the node through the node
ConnTimeout *ct = new ConnTimeout;
cout<<"Please enter the value corresponding to the timeout node fd: ";
cin>>ct->fd;
cout<<"\n Access the data carried on the node through the node in the linked list:"<<endl;
int offset = offsetof(ConnTimeout, node);
ConnTimeout *tmp = (ConnTimeout *)((size_t)p-offset);
printf("offset: %d\n", offset);
printf("Through linked list node node Data accessed:%d\n", tmp->fd);```

Source code implementation

```#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
//int data; // Data field of node
struct _DoubleLinkNode* next; //Pointer field of the next node
struct _DoubleLinkNode* prev; //Pointer field of the previous node
typedef struct {
int fd;
time_t timeout; // Use the timestamp of the timeout time
}ConnTimeout;
typedef struct {
int x; //x coordinate of the star
int y; //y coordinates of stars
enum STATUS stat; //state
int step; //Interval per jump
int color; //The color of stars
}STAR;
L.next = NULL; //The next pointer field of the header node is null
L.prev = NULL; //The prev pointer field of the header node is null
return true;
}

//Tail interpolation
last = &L;
while (last->next) last = last->next;
node.next = NULL;
last->next = &node;
node.prev = last;
return true;
}
int main(void) {
ConnTimeout* cl = NULL, * s = NULL;
STAR* sl = NULL;
int n = 0;
//1. Initialize an empty two-way linked list
cl = new ConnTimeout;
cl->fd = -1;
sl = new STAR;
sl->x = -1;
DbList_Init(cl->node);
DbList_Init(sl->node);
//2. Insert data using tail interpolation
cout << "Creating bidirectional linked list by tail interpolation" << endl;
std::cout << "Please enter the number of elements n: ";
cin >> n;
cout << "\n Please enter in sequence n File handle for elements:" << endl;
while (n > 0) {
s = new ConnTimeout; //Generate new node s
cin >> s->fd;
printf("s Address of:%p node: %p\n", s, &(s->node));
DbListInsert_back(cl->node, s->node);
n--;
}
//3. Access data according to linked list nodes
p = &(cl->node);
cout << "Traverse the nodes in the connection timeout linked list:" << endl;
while (p) {
int offset = offsetof(ConnTimeout, node);
ConnTimeout* ct = (ConnTimeout*)((size_t)p - offset);
cout << ct->fd << endl;
p = p->next;
}
//4. Destroy the two-way linked list
p = &(cl->node);
cout << "Destroy nodes in the connection timeout linked list:" << endl;
while (p) {
int offset = offsetof(ConnTimeout, node);
ConnTimeout* ct = (ConnTimeout*)((size_t)p - offset);
printf("offset: %u ct: %p p:%p\n", offset, ct, p);
cout << ct->fd << endl;
p = p->next;
delete ct;
}
system("pause");
return 0;
}```

# Single linked list complete code

```#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
int data; //Data field of node
struct _LinkNode* next; //Pointer field of node

if (!L) return false;//Failed to generate node
L->next = NULL;
L->data = -1;

return true;
}
//Forward interpolation
if (!L || !node) return false;
node->next = L->next;
L->next = node;
return true;
}
//Tail interpolation
if (!L || !node) return false;
last = L;
while (last->next) last = last->next;
node->next = NULL;
last->next = node;
return true;
}
//Insert at specified location
if (!L) return false;
int j = 0;
p = L;
while (p && j < i - 1) {//Find the node with position i-1, and p points to the node
p = p->next;
j++;
}
if (!p || j > i - 1) {
return false;
}
s = new LinkNode;//Generate new node

s->data = e;
s->next = p->next;
p->next = s;
return true;
}
if (!L) {
cout << "The linked list is empty." << endl;
return;
}
p = L->next;
while (p) {
cout << p->data << "\t";
p = p->next;
}
cout << endl;
}
{
//Find the ith element in the single linked list L of the leading node
//Record the value of the ith data element in L with e
int index;
if (!L || !L->next) return false;
p = L->next;
index = 1;
while (p && index < i) {//Scan the list backward until p points to the ith element or p is empty
p = p->next; //p points to the next node
index++; //The counter index is incremented by 1 accordingly
}
if (!p || index > i) {
return false; //Illegal value of i, i > n or i < = 0
}

e = p->data;
return true;
}
{
//Find the element with value e in the single linked list L of the leading node
p = L->next;
index = 1;
if (!L || !L->next) {
index = 0;
return false;
}
while (p && p->data != e) {
p = p->next;
index++;
}
if (!p) {
index = 0;
return false;//No such value found
}
return true;
}
{
int index = 0;
p = L;
if (!L || !L->next) {
return false;
}
while ((p->next) && (index < i - 1)) {
p = p->next;
index++;
}

if (!p->next || (index > i - 1)) { //When I > n or I < 1, the deletion position is unreasonable
return false;
}
p->next = q->next;//Change the pointer field of the precursor node of the deleted node
delete q; //Free up space for deleted nodes
return true;
}
{
//Define the temporary node p to point to the header node
cout << "Destroy linked list!" << endl;
while (p) {
L = L->next;//L points to the next node
cout << "Delete element: " << p->data << endl;
delete p; //Delete current node
p = L; //p move to next node
}
}
int main(void) {
//1. Initialize an empty linked list
InitList(L);
//2. Insert data using forward interpolation
/*int n;
cout<<"Create single linked list "< < endl" by pre interpolation;
std::cout<<"Please enter the number of elements n: ";
cin>>n;
cout<<"\n Please enter n elements in sequence: "< < endl;
while(n>0){
s = new LinkNode; //Generate new node s
cin>>s->data;
ListInsert_front(L, s);
n--;

}
*/
//3. Insert data using tail interpolation
/*int n;
cout<<"Create single linked list "< < endl" by tail interpolation;
std::cout<<"Please enter the number of elements n: ";
cin>>n;
cout<<"\n Please enter n elements in sequence: "< < endl;
while(n>0){
s = new LinkNode; //Generate new node s
cin>>s->data;
ListInsert_back(L, s);
n--;
}
//4. Output of single linked list
*/
//5. Insert elements anywhere
for (int j = 0; j < 3; j++) {
int i, x;
cout << "Please enter the insertion position and elements (separated by spaces):";
cin >> i;
cin >> x;
cout << "Insert successful.\n\n";
}
else {
cout << "Insert failed!\n\n";
}
}
//6. The single linked list obtains elements according to location
int element = 0;
cout << "Getting the second element succeeded, Value:" << element << endl;
}
else {
cout << "Failed to get the second element!" << endl;
}
//7. The single linked list queries the location of the element according to the value
int index = 0;

cout << "Find element 10 exists,location: " << index << endl;
}
else {
cout << "Element 10 does not exist." << endl;
}
//8. Delete elements from single linked list
cout << "The second element was deleted successfully!" << endl;
}
else {
cout << "Failed to delete the 2nd element!" << endl;
}
//9. Destroy the single linked list
system("pause");
return 0;
}```

# Complete code of circular linked list

```#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
int data; //Data field of node
struct _LinkNode* next; //Pointer field of node

L = new LinkNode; //Generate a new node as the head node, and point to the head node with the head pointer L
if (!L)return false; //Failed to generate node
L->next = L; //The pointer field of the header node points to itself
L->data = -1;
return true;
}
//Tail interpolation
if (!L || !node) return false;

//Last node found
last = L;
while (last->next != L) last = last->next;
//The new node is linked to the tail
node->next = L;
last->next = node;
return true;
}
{
//In the circular linked list L of the leading node, each interval circularly deletes the node
int j = 0, i = 0;
int times = 0, num = 0;
p = L;
if (!L || p->next == L) {
cout << "The linked list is empty!" << endl;
return false;
}
if (interval < 1) {
cout << "The number elimination password cannot be less than 1!" << endl;
return false;
}
do {
i += interval;
while ((p->next)){ //Find the ith node, and p points to the previous node of the node

if (p->next != L) j++;
if (j >= i) break;
p = p->next;
}
times++;
/*if (!(p->next)||(j>i))//When I > n or I < 1, the deletion position is unreasonable
return false;*/
num = q->data;

if (times == 5) cout << "The number of the fifth out circle is:" << num << endl;
printf("cur: %d last: %d next:%d\n", q->data, p->data,
q->next->data);
p->next = q->next; //Change the pointer field of the precursor node of the deleted node
delete q; //Free up space for deleted nodes
} while (L->next != L);//The linked list is not empty. Continue counting
cout << "The number of the last circle is:" << num << endl;
return true;
}
{
if (!L || L == L->next) {
cout << "The linked list is empty!" << endl;
return;
}
p = L->next;
while (p != L){
cout << p->data << "\t";
p = p->next;
}
cout << endl;
}
int main() {
int i, x;
//1. Initialize an empty circular linked list
if (InitList(L)) {
cout << "Initialize an empty circular linked list!\n";
}
//2. Create a circular linked list (tail insertion method)

std::cout << "Creating circular linked list by tail interpolation, Insert 10 elements..." << endl;
i = 0;
while ((++i) <= 10){
s = new LinkNode;//Generate new node
s->data = i; //The input element value is assigned to the data field of the new node
s->next = NULL;
if (ListInsert_back(L, s)) {
cout << "Insert successful!" << endl;
}
else {
cout << "Insert failed!" << endl;
}
}
cout << "Tail interpolation method to create circular linked list output results:\n";
Joseph(L, 9);
system("pause");
return 0;
}```

# Two way linked list complete code

```#include<iostream>
#include<string>
#include<stdlib.h>
using namespace std;
int data; //Data field of node
struct _DoubleLinkNode* next; //Pointer field of the next node
struct _DoubleLinkNode* prev; //Pointer field of the previous node

L = new DbLinkNode; //Generate a new node as the head node, and point to the head node with the head pointer L
if (!L)return false; //Failed to generate node
L->next = NULL; //The next pointer field of the header node is null
L->prev = NULL; //The prev pointer field of the header node is null
L->data = -1;
return true;
}
//Forward interpolation
if (!L || !node) return false;
if (L->next == NULL) {
node->next = NULL;
node->prev = L; //The new node prev pointer points to the header node
L->next = node; //The next pointer of the header node points to the new node
}
else {
L->next->prev = node; //The prev of the second node points to the new node
node->next = L->next; //The new node next pointer points to the second node
node->prev = L; //The new node prev pointer points to the header node
L->next = node; //The next pointer of the header node points to the new node to complete the insertion
}
return true;
}
//Tail interpolation
if (!L || !node) return false;
last = L;
while (last->next) last = last->next;
node->next = NULL;
last->next = node;
node->prev = last;
return true;
}
//Insert at specified location
if (!L || !L->next) return false;
if (i < 1) return false;
int j = 0;
p = L;
while (p && j < i) {//Find the node with position i, and p points to the node
p = p->next;
j++;
}
if (!p || j != i) {
cout << "Node does not exist:" << i << endl;
return false;
}
cout << "p: " << p << endl;
s = new DbLinkNode;//Generate new node
s->data = e;
s->next = p;
s->prev = p->prev;
p->prev->next = s;
p->prev = s;
return true;
}
if (!L) {
cout << "The linked list is empty." << endl;
return;
}
p = L;
while (p->next) {
cout << p->next->data << "\t";
p = p->next;
}
//Reverse printing
cout << endl << "Reverse printing" << endl;
while (p) {
cout << p->data << "\t";
p = p->prev;
}
cout << endl;
}
//Find the ith element in the two-way linked list L of the leading node
//Record the value of the ith data element in L with e
int index;
if (!L || !L->next) return false;
p = L->next;
index = 1;
while (p && index < i) {//Scan the list backward until p points to the ith element or p is empty
p = p->next; //p points to the next node
index++; //The counter index is incremented by 1 accordingly
}
if (!p || index > i) {
return false; //Illegal value of i, i > n or i < = 0
}
e = p->data;
return true;
}
int index = 0;
if (!L || !L->next) {
cout << "The two-way linked list is empty!" << endl;
return false;
}
if (i < 1) return false; //You cannot delete a header node
p = L;
while (p && index < i) {
p = p->next;
index++;
}
if (!p) { //Failure is returned when the node does not exist
return false;
}
p->prev->next = p->next; //Change the next pointer field of the predecessor node of the deleted node
p->next->prev = p->prev; //Change the prev pointer field of the successor node after deleting the node
delete p; //Free up space for deleted nodes
return true;
}
//Define the temporary node p to point to the header node
cout << "Destroy linked list!" << endl;
while (p) {
L = L->next;//L points to the next node
cout << "Delete element: " << p->data << endl;
delete p; //Delete current node
p = L; //p move to next node
}
}
int main(void) {
//1. Initialize an empty two-way linked list
DbList_Init(L);
//2. Insert data using forward interpolation
int n;
cout << "Creating bidirectional linked list by forward interpolation" << endl;
std::cout << "Please enter the number of elements n: ";
cin >> n;
cout << "\n Please enter in sequence n Elements:" << endl;
while (n > 0) {
s = new DbLinkNode; //Generate new node s
cin >> s->data;
DbListInsert_front(L, s);
n--;
}
//3. Insert data using tail interpolation
cout << "Creating bidirectional linked list by tail interpolation" << endl;
std::cout << "Please enter the number of elements n: ";
cin >> n;
cout << "\n Please enter in sequence n Elements:" << endl;
while (n > 0) {
s = new DbLinkNode; //Generate new node s
cin >> s->data;
DbListInsert_back(L, s);
n--;
}
//4. Output of bidirectional linked list
//5. Insert elements anywhere
for (int j = 0; j < 3; j++) {
int i, x;
cout << "Please enter the insertion position and elements (separated by spaces):";
cin >> i;
cin >> x;
cout << "Insert successful.\n\n";
}
else {
cout << "Insert failed!\n\n";
}
}
//6. The two-way linked list obtains elements according to location
int element = 0;
cout << "Getting the second element succeeded, Value:" << element << endl;
}
else {
cout << "Failed to get the second element!" << endl;
}
//7. Delete elements from the two-way linked list
cout << "The second element was deleted successfully!" << endl;
}
else {
cout << "Failed to delete the 2nd element!" << endl;
}