C++ Python双向链表

#include

// 链表节点的结构定义
struct Node {
int data; // 节点存储的数据
Node* prev; // 指向前一个节点的指针
Node* next; // 指向下一个节点的指针
};

// 双向链表类定义
class DoublyLinkedList {
private:
Node* head; // 链表头指针，指向第一个节点
Node* tail; // 链表尾指针，指向最后一个节点

public:
// 构造函数，初始化链表为空
DoublyLinkedList() : head(nullptr), tail(nullptr) {}

// 插入节点到链表尾部
void insert(int data) {
    // 创建一个新节点
    Node* newNode = new Node;
    newNode->data = data;
    newNode->prev = nullptr;
    newNode->next = nullptr;

    if (head == nullptr) {
        // 如果链表为空，将头指针指向新节点
        head = newNode;
        tail = newNode;
    } else {
        // 如果链表不为空，将新节点插入到链表尾部
        tail->next = newNode;
        newNode->prev = tail;
        tail = newNode;
    }
}

// 在指定位置插入节点
void insertAt(int position, int data) {
    // 创建一个新节点
    Node* newNode = new Node;
    newNode->data = data;
    newNode->prev = nullptr;
    newNode->next = nullptr;

    if (position == 0) {
        // 如果要插入到链表头部
        newNode->next = head;
        head->prev = newNode;
        head = newNode;
    } else {
        // 遍历链表找到指定位置的前一个节点
        Node* currentNode = head;
        int currentPosition = 0;
        while (currentNode != nullptr && currentPosition < position - 1) {
            currentNode = currentNode->next;
            currentPosition++;
        }

        if (currentNode != nullptr) {
            // 如果找到了位置，将新节点插入
            newNode->next = currentNode->next;
            newNode->prev = currentNode;
            if (currentNode->next != nullptr) {
                currentNode->next->prev = newNode;
            }
            currentNode->next = newNode;
        } else {
            // 如果位置无效，插入到链表尾部
            tail->next = newNode;
            newNode->prev = tail;
            tail = newNode;
        }
    }
}

// 删除指定位置的节点
void removeAt(int position) {
    if (head == nullptr) {
        // 链表为空，无法删除节点
        return;
    }

    if (position == 0) {
        // 删除链表头部节点
        Node* temp = head;
        head = head->next;
        if (head != nullptr) {
            head->prev = nullptr;
        }
        delete temp;
    } else {
        // 遍历链表找到指定位置的节点
        Node* currentNode = head;
        int currentPosition = 0;
        while (currentNode != nullptr && currentPosition < position) {
            currentNode = currentNode->next;
            currentPosition++;
        }

        if (currentNode != nullptr) {
            // 找到了节点，删除它
            Node* prevNode = currentNode->prev;
            Node* nextNode = currentNode->next;
            if (prevNode != nullptr) {
                prevNode->next = nextNode;
            }
            if (nextNode != nullptr) {
                nextNode->prev = prevNode;
            }
            if (currentNode == tail) {
                tail = prevNode;
            }
            delete currentNode;
        }
    }
}

// 打印链表
void display() {
    Node* currentNode = head;
    while (currentNode != nullptr) {
        std::cout << currentNode->data << " ";
        currentNode = currentNode->next;
    }
    std::cout << std::endl;
}

};

int main() {
DoublyLinkedList myList;

// 在链表尾部插入节点
myList.insert(5);
myList.insert(10);
myList.insert(15);

// 在指定位置插入节点
myList.insertAt(1, 20);

// 删除指定位置的节点
myList.removeAt(2);

// 打印链表
myList.display();

return 0;

}

Python:
class Node:
def init(self, data):
self.data = data
self.prev = None
self.next = None

class DoublyLinkedList:
def init(self):
self.head = None # 链表头
self.tail = None # 链表尾

def insert(self, data):
    new_node = Node(data)  # 创建新节点
    if self.head is None:
        # 如果链表为空，将新节点设置为头和尾
        self.head = new_node
        self.tail = new_node
    else:
        # 如果链表不为空，将新节点插入到链表尾部
        new_node.prev = self.tail
        self.tail.next = new_node
        self.tail = new_node

def insert_at(self, position, data):
    new_node = Node(data)  # 创建新节点
    if position == 0:
        # 如果要插入到链表头部
        new_node.next = self.head
        self.head.prev = new_node
        self.head = new_node
    else:
        current_node = self.head
        current_position = 0
        while current_node is not None and current_position < position - 1:
            current_node = current_node.next
            current_position += 1

        if current_node is not None:
            # 找到指定位置，将新节点插入
            new_node.prev = current_node
            new_node.next = current_node.next
            if current_node.next:
                current_node.next.prev = new_node
            current_node.next = new_node
        else:
            # 如果位置无效，插入到链表尾部
            self.tail.next = new_node
            new_node.prev = self.tail
            self.tail = new_node

def remove_at(self, position):
    if self.head is None:
        # 链表为空，无法删除节点
        return
    
    if position == 0:
        # 删除链表头部节点
        if self.head == self.tail:
            # 如果只有一个节点，则将头和尾都设为None
            self.head = None
            self.tail = None
        else:
            self.head = self.head.next
            self.head.prev = None
    else:
        current_node = self.head
        current_position = 0
        while current_node is not None and current_position < position:
            current_node = current_node.next
            current_position += 1

        if current_node is not None:
            # 找到节点，删除它
            if current_node == self.tail:
                self.tail = current_node.prev
                self.tail.next = None
            else:
                current_node.prev.next = current_node.next
                current_node.next.prev = current_node.prev

def display(self):
    current_node = self.head
    while current_node is not None:
        print(current_node.data, end=" ")
        current_node = current_node.next
    print()

创建双向链表对象

my_list = DoublyLinkedList()

在链表尾部插入节点

my_list.insert(5)
my_list.insert(10)
my_list.insert(15)

在指定位置插入节点

my_list.insert_at(1, 20)

删除指定位置的节点

my_list.remove_at(2)

打印链表

my_list.display()