int createList(Node **head); void printList(Node *head); Node *searchNode(Node *head, int id); Node *deleteNode(Node *head, int pos);

这是一个 C 语言中的链表操作函数声明，具体说明如下：

- `int createList(Node **head);`：创建一个链表，并将头结点的地址存储在 head 指针所指向的地址中。返回值为链表长度。
- `void printList(Node *head);`：遍历链表，输出链表中所有节点的值。
- `Node *searchNode(Node *head, int id);`：在链表中查找节点值为 id 的节点，并返回该节点的地址。若未找到，返回 NULL。
- `Node *deleteNode(Node *head, int pos);`：删除链表中位置为 pos 的节点，并返回删除节点后的链表头节点地址。若 pos 位置不存在，返回原链表头节点地址。

需要注意的是，这里的 Node 是一个结构体类型，包含一个整型变量和一个指向下一节点的指针，具体实现可以参考以下代码：

typedef struct Node {
    int val;
    struct Node *next;
} Node;

相关问题

C++用单链表为某个单位建立一个员工通讯录管理系统，可以方便查询每一个员工的手机号、及电子邮箱。其功能包括通讯录链表的建立、员工通讯信息的查询、修改、插入与删除、以及整个通讯录表的输出。 操作分为查询、修改、添加、删除、打印 1. 查询：输入员工姓名，输出员工信息，若员工不存在，输出“NOT FOUND!” 2. 修改：输入员工姓名、要修改的属性，修改信息。姓名为name、电话为tel、邮箱为mail。 3. 添加：输入员工编号、姓名、电话号码、邮箱。 4. 删除：输入员工姓名，将其从通讯录中删除。 5. 打印：输出通讯录。用到存储结构： typedef struct { /*员工通讯信息的结构类型定义*/ char num[5]; /*员工编号*/ char name[10]; /*员工姓名*/ char tel[15]; /*办公室电话号码*/ char call[15]; /*手机号码*/ char mail[25]; /*邮箱*/ }DataType; /*通讯录单链表的结点类型*/ typedef struct node { DataType data; /*结点的数据域*/ struct node *next; /*结点的指针域*/ }ListNode,*LinkList;代码

以下是基本实现代码，可以根据需要进行修改和完善：

#include <iostream>
#include <cstring>

using namespace std;

typedef struct {
    char num[5];
    char name[10];
    char tel[15];
    char call[15];
    char mail[25];
} DataType;

typedef struct node {
    DataType data;
    struct node *next;
} ListNode, *LinkList;

// 创建通讯录链表
LinkList createList() {
    LinkList head = new ListNode;
    head->next = NULL;
    return head;
}

// 添加员工信息
void insertNode(LinkList L, DataType data) {
    ListNode *p = new ListNode;
    p->data = data;
    p->next = L->next;
    L->next = p;
}

// 查询员工信息
void searchNode(LinkList L, char name[]) {
    ListNode *p = L->next;
    while (p != NULL) {
        if (strcmp(p->data.name, name) == 0) {
            cout << "编号：" << p->data.num << endl;
            cout << "姓名：" << p->data.name << endl;
            cout << "电话：" << p->data.tel << endl;
            cout << "手机：" << p->data.call << endl;
            cout << "邮箱：" << p->data.mail << endl;
            return;
        }
        p = p->next;
    }
    cout << "NOT FOUND!" << endl;
}

// 修改员工信息
void modifyNode(LinkList L, char name[], char field[], char value[]) {
    ListNode *p = L->next;
    while (p != NULL) {
        if (strcmp(p->data.name, name) == 0) {
            if (strcmp(field, "name") == 0) {
                strcpy(p->data.name, value);
            } else if (strcmp(field, "tel") == 0) {
                strcpy(p->data.tel, value);
            } else if (strcmp(field, "call") == 0) {
                strcpy(p->data.call, value);
            } else if (strcmp(field, "mail") == 0) {
                strcpy(p->data.mail, value);
            } else {
                cout << "Invalid field!" << endl;
                return;
            }
            cout << "Modify succeed!" << endl;
            return;
        }
        p = p->next;
    }
    cout << "NOT FOUND!" << endl;
}

// 删除员工信息
void deleteNode(LinkList L, char name[]) {
    ListNode *p = L->next, *pre = L;
    while (p != NULL) {
        if (strcmp(p->data.name, name) == 0) {
            pre->next = p->next;
            delete(p);
            cout << "Delete succeed!" << endl;
            return;
        }
        pre = p;
        p = p->next;
    }
    cout << "NOT FOUND!" << endl;
}

// 输出通讯录
void printList(LinkList L) {
    ListNode *p = L->next;
    while (p != NULL) {
        cout << "编号：" << p->data.num << endl;
        cout << "姓名：" << p->data.name << endl;
        cout << "电话：" << p->data.tel << endl;
        cout << "手机：" << p->data.call << endl;
        cout << "邮箱：" << p->data.mail << endl;
        p = p->next;
    }
}

int main() {
    LinkList L = createList();
    int choice;
    char name[10];
    char field[10];
    char value[25];
    DataType data;
    while (true) {
        cout << "1.查询 2.修改 3.添加 4.删除 5.打印 0.退出" << endl;
        cin >> choice;
        if (choice == 0) {
            break;
        }
        switch (choice) {
            case 1:
                cout << "请输入员工姓名：";
                cin >> name;
                searchNode(L, name);
                break;
            case 2:
                cout << "请输入员工姓名：";
                cin >> name;
                cout << "请输入要修改的属性（name/tel/call/mail）：";
                cin >> field;
                cout << "请输入新值：";
                cin >> value;
                modifyNode(L, name, field, value);
                break;
            case 3:
                cout << "请输入员工编号、姓名、电话、手机、邮箱：";
                cin >> data.num >> data.name >> data.tel >> data.call >> data.mail;
                insertNode(L, data);
                cout << "Add succeed!" << endl;
                break;
            case 4:
                cout << "请输入员工姓名：";
                cin >> name;
                deleteNode(L, name);
                break;
            case 5:
                printList(L);
                break;
            default:
                cout << "Invalid choice!" << endl;
                break;
        }
    }
    return 0;
}

基于带头结点的链式存储结构，编写程序，实现下述功能： 初始化一个空链表 链表的置空和销毁 实现元素的查找、插入和删除 输出链表的全部元素 链表元素的排序及有序链表的合并(选做) 链表的原地逆置(选做) 假定处理的线性表元素是int型的数据。 C语言

基于C语言，我们可以创建一个简单的单向链表结构，并实现所需的功能：

#include <stdio.h>
#include <stdlib.h>

// 定义链表节点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 初始化一个空链表
Node* createList() {
    return (Node*)malloc(sizeof(Node));
}

// 插入节点到链表头部
void insertAtHead(Node** head, int value) {
    Node* newNode = createList();
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

// 查找元素
Node* search(Node* head, int value) {
    while (head != NULL) {
        if (head->data == value)
            return head;
        head = head->next;
    }
    return NULL;
}

// 删除指定值的节点
void deleteNode(Node** head, int value) {
    Node* temp = *head, *prev;

    // 如果头节点就是目标节点
    if (temp != NULL && temp->data == value) {
        *head = temp->next; // 更新头节点
        free(temp);         // 释放原头节点内存
        return;
    }

    // 遍历链表寻找目标节点
    while (temp != NULL && temp->data != value) {
        prev = temp;
        temp = temp->next;
    }

    // 如果找到目标节点
    if (temp != NULL) {
        prev->next = temp->next; // 将当前节点从链表中移除
        free(temp);              // 释放节点内存
    }
}

// 输出链表元素
void printList(Node* head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

// 简单排序并输出已排序的链表
void sortAndPrint(Node** head) {
    if (*head == NULL || (*head)->next == NULL)
        return;

    Node* end = *head;
    while (end->next != NULL)
        end = end->next;

    for (Node* it = *head; it != end; it = it->next) {
        for (Node* j = it; j != end; j = j->next) {
            if (j->data > it->data) {
                int temp = it->data;
                it->data = j->data;
                j->data = temp;
            }
        }
    }
    printList(*head);
}

// 原地逆置链表
void reverseList(Node** head) {
    Node* prev = NULL, *current = *head, *next;

    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    *head = prev;
}

int main() {
    Node* head = createList(); // 初始化空链表

    // 插入元素
    insertAtHead(&head, 5);
    insertAtHead(&head, 3);
    insertAtHead(&head, 7);

    // 打印链表
    printf("Original list: ");
    printList(head);

    // 删除元素
    deleteNode(&head, 3);
    
    // 查找元素
    Node* foundNode = search(head, 7);
    if (foundNode != NULL)
        printf("Found element: %d\n", foundNode->data);
    else
        printf("Element not found.\n");

    // 排序并打印链表
    sortAndPrint(&head);

    // 逆置链表
    reverseList(&head);

    // 输出逆置后的链表
    printf("Reversed list: ");
    printList(head);

    // 销毁链表
    destroyList(head);

    return 0;
}

// 示例函数，未在此代码中实际实现，用于链表销毁
void destroyList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        Node* nextTemp = temp->next;
        free(temp);
        temp = nextTemp;
    }
}

在这个例子中，我们首先定义了链表节点结构，然后实现了链表的创建、插入、查找、删除、打印、排序、逆置以及简单销毁操作。注意，`destroyList()` 函数在这里未实际实现，它是一个辅助函数，用于释放整个链表的内存。如果你需要，可以添加相应的代码来实现这个函数。