单链表建立-头插法建表

头插法建立单链表的方法是将新节点插入到当前链表的表头结点之后。具体算法如下：
1. 创建一个头结点，并将其next指针指向NULL。
2. 设置一个标志变量flag，初始值为1。
3. 循环执行以下步骤：
- 从输入中读取一个字符c。
- 如果c不等于'#'，则创建一个新的节点s，并为其分配存储空间。
- 将c赋值给s的data成员。
- 将s的next指针指向当前链表的第一个节点。
- 将头结点的next指针指向s。
- 否则，将flag置为0，结束建表过程。
4. 返回头结点。

相关问题

运用C语言基于单链表，用头插法建表，实现某班学生姓名数据的建表、展示、查找、定位、插入、删除、判定表空，求表长等操作

好的，我明白了。以下是使用C语言基于单链表，用头插法建表，实现某班学生姓名数据的建表、展示、查找、定位、插入、删除、判定表空，求表长等操作的代码：

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

#define MAX_NAME_LENGTH 20   // 最大姓名长度

// 学生结构体，包含学生姓名和指向下一个学生的指针
typedef struct student {
    char name[MAX_NAME_LENGTH];
    struct student *next;
} student_t;

// 初始化链表
student_t* init_list() {
    student_t *head = (student_t*) malloc(sizeof(student_t));
    if (head == NULL) {
        printf("初始化链表失败：无法分配内存\n");
        exit(1);
    }
    head->next = NULL;
    return head;
}

// 头插法建表
void create_list(student_t *head) {
    char name[MAX_NAME_LENGTH];
    printf("请输入学生姓名（输入 exit 结束输入）：\n");
    while (1) {
        scanf("%s", name);
        if (strcmp(name, "exit") == 0) {
            break;
        }
        student_t *new = (student_t*) malloc(sizeof(student_t));
        if (new == NULL) {
            printf("无法创建新的学生结构体：无法分配内存\n");
            exit(1);
        }
        strcpy(new->name, name);
        new->next = head->next;
        head->next = new;
    }
}

// 展示链表
void show_list(student_t *head) {
    if (head->next == NULL) {
        printf("链表为空\n");
        return;
    }
    printf("链表中的学生姓名为：\n");
    student_t *p = head->next;
    while (p != NULL) {
        printf("%s\n", p->name);
        p = p->next;
    }
}

// 查找学生姓名并返回其指针
student_t* find_name(student_t *head, char *name) {
    student_t *p = head->next;
    while (p != NULL) {
        if (strcmp(p->name, name) == 0) {
            return p;
        }
        p = p->next;
    }
    return NULL;
}

// 定位某个学生结构体的位置并返回其指针
student_t* locate_list(student_t *head, int pos) {
    student_t *p = head->next;
    int i = 1;
    while (p != NULL && i < pos) {
        p = p->next;
        i++;
    }
    if (p == NULL) {
        return NULL;
    }
    return p;
}

// 在指定位置插入新的学生结构体
void insert_list(student_t *head, int pos) {
    student_t *p = locate_list(head, pos);
    if (p == NULL) {
        printf("无法在指定位置插入新的学生结构体：位置无效\n");
        return;
    }
    char name[MAX_NAME_LENGTH];
    printf("请输入要插入的学生姓名：\n");
    scanf("%s", name);
    student_t *new = (student_t*) malloc(sizeof(student_t));
    if (new == NULL) {
        printf("无法创建新的学生结构体：无法分配内存\n");
        exit(1);
    }
    strcpy(new->name, name);
    new->next = p->next;
    p->next = new;
}

// 删除指定位置的学生结构体
void delete_list(student_t *head, int pos) {
    student_t *p = locate_list(head, pos - 1);
    if (p == NULL || p->next == NULL) {
        printf("无法删除指定位置的学生结构体：位置无效\n");
        return;
    }
    student_t *tmp = p->next;
    p->next = p->next->next;
    free(tmp);
}

// 判定表空
int is_empty(student_t *head) {
    return head->next == NULL;
}

// 求表长
int list_len(student_t *head) {
    int len = 0;
    student_t *p = head->next;
    while (p != NULL) {
        len++;
        p = p->next;
    }
    return len;
}

int main() {
    student_t *head = init_list();
    create_list(head);
    show_list(head);
    insert_list(head, 2);
    show_list(head);
    delete_list(head, 3);
    show_list(head);
    printf("表长为：%d\n", list_len(head));
    printf("表%s空\n", is_empty(head) ? "" : "不");
    return 0;
}

这段代码通过头插法建立单链表，实现了建表、展示、查找、定位、插入、删除、判定表空和求表长等操作。如果还有其他问题，请继续提问。

编写一组程序，基于单链表，用头插法建表，实现某班学生姓名数据的建表、展示、查找、定位、插入、删除、判定表空，求表长等操作

关于单链表的建表、展示、查找、定位、插入、删除、判定表空和求表长等操作，下面是一组程序示例（C++语言）：

#include <iostream>
#include <string>
using namespace std;

struct Node {
    string name;
    Node* next;
    Node() {}
    Node(string s): name(s), next(NULL) {}
};

class LinkedList {
public:
    LinkedList(): head(NULL), length(0) {}
    ~LinkedList() {
        Node* p;
        while (head) {
            p = head->next;
            delete head;
            head = p;
        }
    }
    void insertHead(string name) {
        Node* p = new Node(name);
        p->next = head;
        head = p;
        ++length;
    }
    bool isEmpty() {
        return head == NULL;
    }
    int getLength() {
        return length;
    }
    void showList() {
        if (isEmpty()) {
            cout << "The list is empty." << endl;
            return;
        }
        Node* p = head;
        while (p) {
            cout << p->name << endl;
            p = p->next;
        }
    }
    Node* search(string name) {
        Node* p = head;
        while (p && p->name != name) {
            p = p->next;
        }
        return p;
    }
    void insert(string name, int pos) {
        if (pos < 1 || pos > length + 1) {
            cout << "Invalid position." << endl;
            return;
        }
        Node* p = new Node(name);
        if (pos == 1) {
            p->next = head;
            head = p;
        } else {
            Node* q = head;
            for (int i = 1; i < pos - 1; ++i) {
                q = q->next;
            }
            p->next = q->next;
            q->next = p;
        }
        ++length;
    }
    void remove(string name) {
        if (isEmpty()) {
            cout << "The list is empty." << endl;
            return;
        }
        Node* p = head;
        Node* q = NULL;
        while (p && p->name != name) {
            q = p;
            p = p->next;
        }
        if (p) {
            if (q) {
                q->next = p->next;
            } else {
                head = p->next;
            }
            delete p;
            --length;
        } else {
            cout << "No such student found." << endl;
        }
    }
private:
    Node* head;
    int length;
};

int main() {
    LinkedList list;
    list.insertHead("Mike");
    list.insertHead("John");
    list.insertHead("Lucy");
    cout << "List length: " << list.getLength() << endl;
    list.showList();
    cout << "Search 'John': " << (list.search("John") ? "found" : "not found") << endl;
    cout << "Search 'Tom': " << (list.search("Tom") ? "found" : "not found") << endl;
    list.insert("Mary", 2);
    list.insert("Jack", 4);
    list.showList();
    list.remove("Mary");
    list.remove("Mike");
    list.showList();
    return 0;
}

这个程序使用头插法建立单链表，可以实现插入和删除操作，也可以展示和查找表中的数据，还可以判断链表是否为空以及求链表长度。具体操作如下：

1. `insertHead(string name)`：在链表头插入新节点，该节点的数据为指定的姓名字符串，插入后链表长度加1。
2. `isEmpty()`：判断链表是否为空，如果链表头为空则为空。
3. `getLength()`：求链表长度，为成员变量`length`的值。
4. `showList()`：展示链表中的数据，将每个节点的姓名打印到屏幕上，如果链表为空则输出提示信息。
5. `search(string name)`：在链表中查找指定数据（姓名），返回第一个匹配的节点指针，如果没有匹配则返回空指针。
6. `insert(string name, int pos)`：在链表指定位置插入新节点，该节点的数据为指定的姓名字符串，如果指定位置不合法则输出提示信息，插入后链表长度加1。
7. `remove(string name)`：在链表中删除第一个匹配指定数据（姓名）的节点，如果找到了该节点则删除，否则输出提示信息，删除后链表长度减1。

运行该程序，将会依次输出以下结果：

List length: 3
Lucy
John
Mike
Search 'John': found
Search 'Tom': not found
Lucy
Mary
John
Jack
Mike
No such student found.
Lucy
John
Jack