单链表的删除(结构体+链表)
时间: 2024-05-15 18:18:18 浏览: 7
好的,关于单链表的删除,这是一个常见的链表操作。具体步骤如下:
1. 找到需要删除节点的前一个节点prev。
2. 将prev节点的next指针指向需要删除节点的下一个节点next。
3. 释放需要删除节点的内存空间。
代码示例:
```c
// 定义链表结构体
struct ListNode {
int val;
struct ListNode *next;
};
// 删除节点函数
void deleteNode(struct ListNode* head, int val){
struct ListNode* prev = head;
struct ListNode* cur = head->next;
while(cur != NULL){
if(cur->val == val){
prev->next = cur->next;
free(cur);
return;
}
prev = cur;
cur = cur->next;
}
}
```
以上是一个简单的单链表删除操作。需要注意的是,这个函数只会删除第一次出现的val值节点,如果需要删除所有的val值节点,需要稍作修改。
相关问题
go语言编程编写程序基于结构体和指针定义单链表和双向循环链表。
好的,下面给出 Go 语言实现单链表和双向循环链表的代码。
## 单链表
```go
package main
import "fmt"
// 定义单链表结点
type ListNode struct {
Val int
Next *ListNode
}
// 定义单链表
type LinkedList struct {
Head *ListNode
Tail *ListNode
}
// 添加结点
func (list *LinkedList) AddNode(val int) {
node := &ListNode{Val: val}
if list.Head == nil {
list.Head = node
list.Tail = node
} else {
list.Tail.Next = node
list.Tail = node
}
}
// 删除结点
func (list *LinkedList) RemoveNode(val int) {
if list.Head == nil {
return
}
if list.Head.Val == val {
list.Head = list.Head.Next
if list.Head == nil {
list.Tail = nil
}
return
}
prev, curr := list.Head, list.Head.Next
for curr != nil {
if curr.Val == val {
prev.Next = curr.Next
if curr.Next == nil {
list.Tail = prev
}
return
}
prev, curr = curr, curr.Next
}
}
// 打印链表
func (list *LinkedList) PrintList() {
curr := list.Head
for curr != nil {
fmt.Printf("%d -> ", curr.Val)
curr = curr.Next
}
fmt.Println("nil")
}
func main() {
list := &LinkedList{}
list.AddNode(1)
list.AddNode(2)
list.AddNode(3)
list.PrintList() // 1 -> 2 -> 3 -> nil
list.RemoveNode(2)
list.PrintList() // 1 -> 3 -> nil
}
```
## 双向循环链表
```go
package main
import "fmt"
// 定义双向循环链表结点
type ListNode struct {
Val int
Prev *ListNode
Next *ListNode
}
// 定义双向循环链表
type LinkedList struct {
Head *ListNode
Tail *ListNode
}
// 添加结点
func (list *LinkedList) AddNode(val int) {
node := &ListNode{Val: val}
if list.Head == nil {
node.Prev = node
node.Next = node
list.Head = node
list.Tail = node
} else {
list.Tail.Next = node
node.Prev = list.Tail
node.Next = list.Head
list.Head.Prev = node
list.Tail = node
}
}
// 删除结点
func (list *LinkedList) RemoveNode(val int) {
if list.Head == nil {
return
}
curr := list.Head
for curr != nil {
if curr.Val == val {
if curr == list.Head {
list.Head = curr.Next
}
if curr == list.Tail {
list.Tail = curr.Prev
}
curr.Prev.Next = curr.Next
curr.Next.Prev = curr.Prev
return
}
curr = curr.Next
if curr == list.Head {
return
}
}
}
// 打印链表
func (list *LinkedList) PrintList() {
curr := list.Head
for curr != nil {
fmt.Printf("%d <-> ", curr.Val)
curr = curr.Next
if curr == list.Head {
break
}
}
fmt.Println("head")
}
func main() {
list := &LinkedList{}
list.AddNode(1)
list.AddNode(2)
list.AddNode(3)
list.PrintList() // 1 <-> 2 <-> 3 <-> head
list.RemoveNode(2)
list.PrintList() // 1 <-> 3 <-> head
}
```
用C语言写一个单链表,包括创建链表,查找,删除,插入
以下是用 C 语言实现单链表的代码:
```c
#include <stdio.h>
#include <stdlib.h>
// 定义链表节点结构体
typedef struct Node {
int data;
struct Node *next;
} Node;
// 创建链表
Node *createList(int n) {
Node *head = NULL, *tail = NULL;
for (int i = 0; i < n; i++) {
Node *node = (Node *)malloc(sizeof(Node));
printf("请输入第 %d 个节点的值:", i + 1);
scanf("%d", &node->data);
node->next = NULL;
if (head == NULL) {
head = node;
tail = node;
} else {
tail->next = node;
tail = node;
}
}
return head;
}
// 查找节点
Node *findNode(Node *head, int value) {
Node *p = head;
while (p != NULL && p->data != value) {
p = p->next;
}
return p;
}
// 删除节点
Node *deleteNode(Node *head, int value) {
Node *p = head, *prev = NULL;
while (p != NULL && p->data != value) {
prev = p;
p = p->next;
}
if (p == NULL) {
printf("未找到要删除的节点\n");
return head;
}
if (prev == NULL) {
head = p->next;
} else {
prev->next = p->next;
}
free(p);
printf("已删除节点:%d\n", value);
return head;
}
// 插入节点
Node *insertNode(Node *head, int value, int position) {
Node *node = (Node *)malloc(sizeof(Node));
node->data = value;
node->next = NULL;
if (position == 1) {
node->next = head;
head = node;
} else {
Node *p = head;
for (int i = 1; i < position - 1 && p != NULL; i++) {
p = p->next;
}
if (p == NULL) {
printf("插入位置无效\n");
} else {
node->next = p->next;
p->next = node;
}
}
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);
int value, position;
printf("请输入要查找的节点的值:");
scanf("%d", &value);
Node *node = findNode(head, value);
if (node == NULL) {
printf("未找到节点\n");
} else {
printf("已找到节点:%d\n", node->data);
}
printf("请输入要删除的节点的值:");
scanf("%d", &value);
head = deleteNode(head, value);
printf("删除节点后的链表为:");
printList(head);
printf("请输入要插入的节点的值和位置:");
scanf("%d %d", &value, &position);
head = insertNode(head, value, position);
printf("插入节点后的链表为:");
printList(head);
return 0;
}
```
如果您有任何问题或建议,请随时告诉我。