数据结构中 单链表的遍历操作,用代码表示
时间: 2023-03-25 11:03:40 浏览: 75
单链表的遍历操作可以使用循环来实现,具体代码如下:
```
void traverseList(ListNode* head) {
ListNode* cur = head;
while (cur != NULL) {
// 对当前节点进行操作
// ...
cur = cur->next;
}
}
```
其中,`ListNode` 表示链表节点的结构体,包含一个指向下一个节点的指针 `next`。`head` 表示链表的头节点,`cur` 表示当前节点,初始值为头节点。在循环中,对当前节点进行操作后,将 `cur` 指向下一个节点,直到 `cur` 为 `NULL`,即遍历完整个链表。
相关问题
数据结构单链表四个操作代码
单链表是一种常见的数据结构,它由多个节点组成,每个节点都包含了一个数据元素和指向下一个节点的指针。单链表常用的四个操作包括:创建链表、插入节点、删除节点和遍历链表。以下是使用 C 语言实现单链表的四个操作的代码示例:
```c
#include <stdio.h>
#include <stdlib.h>
// 定义单链表节点的结构体
typedef struct ListNode {
int val; // 节点存储的数据
struct ListNode* next; // 指向下一个节点的指针
} ListNode;
// 创建一个新的节点
ListNode* createNode(int val) {
ListNode* node = (ListNode*)malloc(sizeof(ListNode));
node->val = val;
node->next = NULL;
return node;
}
// 创建一个单链表并返回头节点
ListNode* createList(int* arr, int n) {
if (n == 0) return NULL;
ListNode* head = createNode(arr[0]);
ListNode* p = head;
for (int i = 1; i < n; i++) {
p->next = createNode(arr[i]);
p = p->next;
}
return head;
}
// 在单链表的指定位置插入一个新节点
void insertNode(ListNode* head, int pos, int val) {
ListNode* node = createNode(val);
// 找到要插入位置的前一个节点
ListNode* p = head;
for (int i = 0; i < pos - 1; i++) {
p = p->next;
}
// 插入新节点
node->next = p->next;
p->next = node;
}
// 在单链表中删除指定位置的节点
void deleteNode(ListNode* head, int pos) {
// 找到要删除节点的前一个节点
ListNode* p = head;
for (int i = 0; i < pos - 1; i++) {
p = p->next;
}
// 删除节点
ListNode* node = p->next;
p->next = node->next;
free(node);
}
// 遍历单链表
void traverseList(ListNode* head) {
ListNode* p = head;
while (p) {
printf("%d ", p->val);
p = p->next;
}
printf("\n");
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
int n = sizeof(arr) / sizeof(int);
ListNode* head = createList(arr, n);
traverseList(head);
insertNode(head, 2, 6);
traverseList(head);
deleteNode(head, 3);
traverseList(head);
return 0;
}
```
数据结构c语言单链表基本操作
单链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。C语言中实现单链表的基本操作包括:创建链表、插入节点、删除节点、查找节点、遍历链表等。其中,插入节点和删除节点是单链表的核心操作。在插入节点时,需要先找到要插入位置的前一个节点,然后将新节点插入到该节点之后;在删除节点时,需要先找到要删除节点的前一个节点,然后将该节点从链表中删除。以下是单链表的基本操作代码示例:
1. 创建链表
```
LinkList CreateList() {
LinkList L = (LinkList)malloc(sizeof(LNode));
L->next = NULL;
return L;
}
```
2. 插入节点
```
bool ListInsert(LinkList L, int i, ElemType e) {
if (i < 1) {
return false;
}
LNode *p = L;
int j = 0;
while (p != NULL && j < i - 1) {
p = p->next;
j++;
}
if (p == NULL) {
return false;
}
LNode *s = (LNode *)malloc(sizeof(LNode));
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
```
3. 删除节点
```
bool ListDelete(LinkList L, int i, ElemType &e) {
if (i < 1) {
return false;
}
LNode *p = L;
int j = 0;
while (p != NULL && j < i - 1) {
p = p->next;
j++;
}
if (p == NULL || p->next == NULL) {
return false;
}
LNode *q = p->next;
e = q->data;
p->next = q->next;
free(q);
return true;
}
```
4. 查找节点
```
LNode *GetElem(LinkList L, int i) {
if (i < 1) {
return NULL;
}
LNode *p = L->next;
int j = 1;
while (p != NULL && j < i) {
p = p->next;
j++;
}
return p;
}
```
5. 遍历链表
```
void TraverseList(LinkList L) {
LNode *p = L->next;
while (p != NULL) {
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}
```