建立一个长度为n的单链表

以下是使用Python语言实现建立长度为n的单链表的代码：

class Node:
    def __init__(self, value=None, next=None):
        self.value = value
        self.next = next

def createLinkedList(n):
    head = None
    for i in range(n):
        value = int(input("请输入第%d个节点的值：" % (i+1)))
        node = Node(value)
        if head is None:
            head = node
        else:
            cur = head
            while cur.next is not None:
                cur = cur.next
            cur.next = node
    return head

n = int(input("请输入链表长度："))
head = createLinkedList(n)

运行代码后，程序会提示你输入每个节点的值，最终返回创建好的单链表的头节点。你可以根据实际需要修改代码，例如可以使用其他编程语言实现相同的功能。

相关问题

用C语逆序建立一个单链表

可以使用以下代码来逆序建立一个单链表：

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

typedef struct node {
int data;
struct node *next;
} Node;

Node *createList(int n) {
Node *head = NULL, *p = NULL;
int i, data;
for (i = 0; i < n; i++) {
printf("请输入第%d个节点的值：", i + 1);
scanf("%d", &data);
p = (Node *) malloc(sizeof(Node));
p->data = data;
p->next = head;
head = p;
}
return head;
}

void printList(Node *head) {
Node *p = head;
while (p != NULL) {
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}

int main() {
int n;
printf("请输入链表的长度：");
scanf("%d", &n);
Node *head = createList(n);
printf("原始链表：");
printList(head);

Node *prev = NULL, *curr = head, *next = NULL;
while (curr != NULL) {
next = curr->next;
curr->next = prev;
prev = curr;
curr = next;
}
head = prev;

printf("逆序链表：");
printList(head);

return 0;
}

建立长度为n的单链表，n>0，删除单链表中等于给定值的元素。数据类型指定为整型。

### 回答1：
首先需要定义一个单链表的结构体，包含一个整型数据域和一个指向下一个节点的指针域。然后，可以通过循环创建一个长度为n的单链表，每次创建一个新节点并将其插入到链表的末尾。

接下来，可以遍历整个链表，查找并删除所有等于给定值的节点。具体实现可以使用两个指针，一个指向当前节点，另一个指向当前节点的前一个节点。如果当前节点的数据域等于给定值，则将前一个节点的指针指向当前节点的下一个节点，然后释放当前节点的内存空间。如果当前节点的数据域不等于给定值，则将两个指针都向后移动一个节点。

最后，需要记得释放链表的头节点的内存空间，并将头节点的指针设为NULL，以避免内存泄漏。

### 回答2：
1. 建立单链表

首先需要了解单链表的结构和建立方法。单链表由一个头结点和若干个数据结点组成，每个结点包含两部分信息：一部分是数据域，用来存储数据；另一部分是指针域，用来指向下一个结点。可以利用结构体来定义单链表的结点数据类型。

代码示例：

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

在建立单链表时需要考虑头结点和数据结点的区别。对于头结点来说，它本身不存储数据，只是一个指向第一个数据结点的指针。因此，在建立单链表时需要先创建一个头结点，并将它的指针域指向第一个数据结点。

代码示例：

ListNode* createList(int* nums, int n) {
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->next = NULL;
    ListNode* tail = head;
    for (int i = 0; i < n; i++) {
        ListNode* node = (ListNode*)malloc(sizeof(ListNode));
        node->val = nums[i];
        node->next = NULL;
        tail->next = node;
        tail = node;
    }
    return head;
}

在上述代码中，使用传入的数组nums和长度n建立单链表，首先创建一个头结点，然后依次创建数据结点，并将它们加入到链表中。

2. 删除指定元素

接下来考虑如何删除单链表中等于给定值的元素。由于单链表只能从头到尾依次遍历，因此需要遍历整个链表，寻找指定值的结点。

代码示例：

ListNode* removeElements(ListNode* head, int val) {
    ListNode* dummy = (ListNode*)malloc(sizeof(ListNode));
    dummy->next = head;
    ListNode* cur = dummy;

    while (cur->next != NULL) {
        ListNode* next = cur->next;
        if (next->val == val) {
            cur->next = next->next;
            free(next);
        } else {
            cur = cur->next;
        }
    }

    return dummy->next;
}

在上述代码中，首先创建一个虚拟头结点，它的指针域指向原来的头结点。然后创建一个游标指针cur，初始化为虚拟头结点。游标指针会一直遍历整个链表，寻找需要删除的结点。如果当前结点的值等于给定值，就删除该结点；否则就将游标指针向后移动。最后返回虚拟头结点的指针域，即原来的头结点。

3. 总结

建立长度为n的单链表，可以使用数组和循环来创建链表节点，并将它们相互链接起来。为了删除指定元素，可以利用游标指针和虚拟头结点来遍历整个链表，寻找指定值的结点并删除它。

### 回答3：
单链表是一种经典的数据结构，由若干个节点（Node）组成，每个节点包含两个部分，一个是存储数据的域（data），另一个是存储指向下一个节点的指针（next）。通过next指针，形成了一条链，使得节点之间形成了连接。

我们可以通过遍历单链表的方式，找到需要删除等于给定值的元素。具体的操作方法是，从单链表的第一个节点开始遍历，如果节点中存储的数据等于给定值，则删除该节点。如果删除的是第一个节点，需要特殊处理。如果删除的是中间或末尾节点，需要让上一个节点的next指针指向下一个节点。

下面是一个建立长度为n的单链表并删除指定值元素的实现方法：

1. 定义节点结构体

struct Node {
    int data;
    Node* next;
};

2. 建立长度为n的单链表

Node* createList(int n) {
    Node* head = new Node();
    Node* tail = head;
    for (int i = 0; i < n; ++i) {
        Node* node = new Node();
        cin >> node->data;
        tail->next = node;
        tail = node;
    }
    return head;
}

3. 删除指定值元素

void deleteValue(Node* head, int value) {
    Node* p = head;
    Node* q = p->next;
    while (q) {
        if (q->data == value) {
            p->next = q->next;
            delete q;
            q = p->next;
        } else {
            p = q;
            q = q->next;
        }
    }
}

完整代码如下：

#include <iostream>
using namespace std;

struct Node {
    int data;
    Node* next;
};

Node* createList(int n) {
    Node* head = new Node();
    Node* tail = head;
    for (int i = 0; i < n; ++i) {
        Node* node = new Node();
        cin >> node->data;
        tail->next = node;
        tail = node;
    }
    return head;
}

void deleteValue(Node* head, int value) {
    Node* p = head;
    Node* q = p->next;
    while (q) {
        if (q->data == value) {
            p->next = q->next;
            delete q;
            q = p->next;
        } else {
            p = q;
            q = q->next;
        }
    }
}

void printList(Node* head) {
    Node* p = head->next;
    while (p) {
        cout << p->data << " ";
        p = p->next;
    }
    cout << endl;
}

int main() {
    int n, value;
    cin >> n >> value;
    Node* head = createList(n);
    deleteValue(head, value);
    printList(head);
    return 0;
}

以上就是建立长度为n的单链表并删除指定值元素的实现方法。需要注意的是，如果单链表中存在重复的指定值元素，都会被删除。另外，该方法的时间复杂度为O(n)，空间复杂度为O(1)。