单链表的有参构造 c++

单链表是一种基础的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++中，你可以通过定义一个带参构造函数来初始化一个单链表。这是一个简单的示例：

template <typename T>
class Node {
public:
    T data;          // 数据域
    Node* next;      // 指向下一个节点的指针

    // 带参构造函数
    Node(T value) : data(value), next(nullptr) {}
};

template <typename T>
class LinkedList {
private:
    Node<T>* head;

public:
    // 默认构造函数，链表开始为空
    LinkedList() : head(nullptr) {}

    // 带参数的构造函数，用于创建一个新的链表并插入初始值
    LinkedList(T value) {
        head = new Node<T>(value);
        if (head) {
            head->next = nullptr;
        }
    }

    // 其他链表操作...
};

在这个例子中，`LinkedList`类有一个模板参数`T`，表示链表元素的类型。当你创建`LinkedList`对象时，可以选择传递一个初始值给带参构造函数，这个初始值会被存储在第一个节点的`data`域。

相关问题

单链表实现学生信息c++

单链表是一种简单的数据结构，在C++中可以用来存储学生信息，比如姓名、学号等。首先，我们可以创建一个`Student`类表示每个学生，然后定义一个节点`Node`用于构成链表。

// 定义Student类
class Student {
public:
    std::string name;
    int student_id;
    // 构造函数和其他成员函数
    Student(const std::string& name, int id) : name(name), student_id(id) {}
};

// 定义链表节点
struct Node {
    Student data;      // 存储学生数据
    Node* next;       // 指向下一个节点的指针
    Node(Student&& student) : data(std::move(student)), next(nullptr) {}   // 使用移动构造函数优化内存管理
};

// 链表类
class LinkedList {
private:
    Node* head;

public:
    LinkedList() : head(nullptr) {}

    // 插入新学生
    void insert(Student student) {
        Node* newNode = new Node(std::move(student));
        if (head == nullptr) {
            head = newNode;
        } else {
            Node* current = head;
            while (current->next != nullptr) {
                current = current->next;
            }
            current->next = newNode;
        }
    }

    // 查找学生
    bool find(const std::string& name) const {
        Node* current = head;
        while (current != nullptr) {
            if (current->data.name == name) {
                return true;
            }
            current = current->next;
        }
        return false;
    }

    // 其他操作...
};

定义单链表结构存储多项式C++

在C++中，我们可以使用结构体（struct）或类（class）来定义一个简单的单链表数据结构来存储多项式的系数和项。这里是一个基本的例子，我们创建一个`Term`节点类，包含`Coefficient`（系数）、`Exponent`（指数）以及指向下一个节点的指针：

#include <iostream>

// 定义多项式项的数据结构
class Term {
public:
    int coefficient; // 系数
    int exponent;   // 指数

    // 构造函数初始化节点
    Term(int c = 0, int e = 0) : coefficient(c), exponent(e) {}

    // 节点之间的链接
    Term* next;     // 存储下一个Term的指针
};

// 如果需要链表容器，可以定义一个多项式类
class Polynomial {
private:
    Term* head;  // 链表头节点

public:
    Polynomial() : head(nullptr) {} // 初始化空链表

    // 添加新的项到多项式
    void addTerm(int coef, int exp) {
        Term* newNode = new Term(coef, exp);
        if (head == nullptr) {
            head = newNode;
        } else {
            Term* curr = head;
            while (curr->next != nullptr && curr->exponent < exp) {
                curr = curr->next;
            }
            newNode->next = curr->next;
            curr->next = newNode;
        }
    }

    // 打印多项式
    void print() const {
        Term* curr = head;
        while (curr != nullptr) {
            std::cout << curr->coefficient << "x^" << curr->exponent << " + ";
            curr = curr->next;
        }
        std::cout << "0" << std::endl; // 结尾加上常数项
    }
};