数据结构--单链表的基本操作

单链表的取值：

#include <iostream>  
  
// 定义状态常量  
const int OK = 0;  
const int ERROR = 1;  
  
// 使用typedef为ListNode定义别名LNode  
typedef struct ListNode {  
    int data;  
    struct ListNode *next; // 使用struct ListNode而不是LNode  
} LNode, *LinkList; // 同时定义LNode和LinkList作为ListNode的别名和指针别名  
  
// 辅助函数：创建链表节点  
LNode* createNode(int data) {  
    LNode* newNode = new LNode;  
    if (!newNode) {  
        std::cerr << "Memory allocation failed!" << std::endl;  
        return nullptr;  
    }  
    newNode->data = data;  
    newNode->next = nullptr;  
    return newNode;  
}  
  
// 辅助函数：在链表末尾添加节点  
void appendNode(LinkList &head, int data) {  
    LNode* newNode = createNode(data);  
    if (!head) {  
        head = newNode;  
        return;  
    }  
    LNode* current = head;  
    while (current->next) {  
        current = current->next;  
    }  
    current->next = newNode;  
}  
  
// getelem函数，使用引用传递e  
int getelem(LinkList L, int i, int &e) {  
    LNode *p = L; // 从头节点开始遍历  
    int j = 1; // 声明并初始化变量j  
    while (p && j < i) {  
        p = p->next;  
        ++j;  
    }  
    if (!p || j > i) return ERROR; // 如果p为空或者j大于i，返回ERROR  
    e = p->data; // 将找到的元素赋值给e  
    return OK; // 返回OK  
}  
  
// 其他代码...  
  
int main() {  
    // 创建一个空链表  
    LinkList head = nullptr;  
  
    // 向链表添加节点  
    appendNode(head, 10);  
    appendNode(head, 20);  
    appendNode(head, 60);  
    appendNode(head, 40);  
    appendNode(head, 50);  
  
    // 检索并打印第二个元素（索引从1开始）  
    int element;  
    int status = getelem(head, 3, element);  
    if (status == OK) {  
        std::cout << "Element at index 2 is: " << element << std::endl;  
    } else {  
        std::cout << "Error retrieving element!" << std::endl;  
    }  
 
  
    return 0;  
}

按值查找： 

#include <iostream>  
  
// 定义状态常量  
const int OK = 0;  
const int ERROR = 1;  
using namespace std;
// 使用typedef为ListNode定义别名LNode  
typedef struct ListNode {  
    int data;  
    struct ListNode *next; // 使用struct ListNode而不是LNode  
} LNode, *LinkList; // 同时定义LNode和LinkList作为ListNode的别名和指针别名  
  
// 创建一个新节点  
LNode* CreateNode(int e) {  
    LNode* newNode = new LNode;  
    if (!newNode) {  
        std::cerr << "Memory allocation failed!" << std::endl;  
        return nullptr;  
    }  
    newNode->data = e;
    newNode->next = nullptr;  
    return newNode;  
}  
  
// 插入节点到链表尾部  
void ListInsert(LinkList &L, int e) {  
    LNode* newNode = CreateNode(e);  
    if (!L) {  
        L = newNode; // 如果链表为空，新节点即为头节点  
    } else {  
        LNode* p = L;  
        while (p->next) {  
            p = p->next;  
        }  
        p->next = newNode; // 将新节点添加到链表尾部  
    }  
}  
  
// 遍历链表并打印元素  
void PrintList(LinkList L) {  
    LNode* p = L;  
    while (p) {  
        std::cout << p->data << " ";  
        p = p->next;  
    }  
    cout << endl;  
}  
  
// 查找元素并返回指向该元素的指针，如果未找到则返回nullptr  
LNode* LocateElem(LinkList L, int e) {  
    LNode* p = L;  
    while (p && p->data != e) {  
        p = p->next;  
    }  
    return p; // 如果找到，p不为空；如果未找到，p为空  
}  
  
int main() {  
    // 初始化链表为空  
    LinkList L = nullptr;  
  
    // 插入几个元素到链表  
    ListInsert(L, 1);  
    ListInsert(L, 2);  
    ListInsert(L, 3);  
    ListInsert(L, 4);  
    ListInsert(L, 5);  
  
    // 打印链表以验证元素已正确插入  
    PrintList(L);  
  
    // 查找元素3并打印结果  
    LNode* p = LocateElem(L, 3);  
    if (p) {  
        cout << "Element found: " << p->data << endl;  
    } else {  
        cout << "Element not found." << endl;  
    }  
  
    // 查找元素10（不存在）并打印结果  
    p = LocateElem(L, 10);  
    if (p) {  
        cout << "Element found: " << p->data << endl;  
    } else {  
        cout << "Element not found." << endl;  
    }  

    return 0;  
}

单链表的遍历输出：

#include <iostream>  
  
// 假设 DataType 已经定义，例如 using DataType = int;  
using DataType = int;  
  
struct Node {  
    DataType data;  
    Node* next;  
  
    Node(DataType val = 0, Node* nextPtr = nullptr) : data(val), next(nextPtr) {}  
};  
  
// 建立一个带头结点的空链表  
Node* InitList() {  
    Node* first = new Node; // 分配头结点内存  
    first->next = nullptr;    // 初始化头结点的next指针为nullptr  
    return first;  
}  
  
// 遍历单链表  
void PrintList(Node* first) {  
    Node* p = first->next; // 从头结点的下一个节点开始遍历  
    while (p != nullptr) {  
        std::cout << p->data << " ";  
        p = p->next;  
    }  
    std::cout << std::endl;  
}  
  
// 在头结点后面插入一个新结点，结点的数据域的值为x  
void InsertAtHead(Node* first, DataType x) {  
    Node* newNode = new Node(x); // 分配新节点内存并初始化数据域  
    newNode->next = first->next; // 将新节点的next指针指向原头结点的下一个节点  
    first->next = newNode;       // 更新头结点的next指针，指向新节点  
}  
  
// 注意：在实际应用中，你可能需要考虑内存释放的问题，例如在删除节点或销毁链表时。  
// 但在这个简单的例子中，我们没有涉及这些操作。  
  
int main() {  
    // 示例用法  
    Node* list = InitList();  
    InsertAtHead(list, 1);  
    InsertAtHead(list, 2);  
    InsertAtHead(list, 3);  
    PrintList(list); // 输出：3 2 1  
    return 0;  
}