数组模拟单链表(详细注释)

本文详细讲解了一个使用C++实现的链表,介绍了如何进行头部插入、按位置删除和在指定位置插入的操作。通过实例演示了如何处理插入顺序和删除节点,最后展示了完整的链表输出过程。

例题来自acwing826,不得不说y总代码确实简单易懂

实现一个单链表,链表初始为空,支持三种操作:

  1. 向链表头插入一个数;
  2. 删除第 k 个插入的数后面的数;
  3. 在第 k个插入的数后插入一个数。

现在要对该链表进行 M 次操作,进行完所有操作后,从头到尾输出整个链表。

注意:题目中第 k 个插入的数并不是指当前链表的第 k 个数。例如操作过程中一共插入了 n 个数,则按照插入的时间顺序,这 n 个数依次为:第 1 个插入的数,第 2 个插入的数,…第 n 个插入的数。

k是指插入的第几个数,这点要注意

#include<iostream>
#include<cstring>
using namespace std;
const int manx = 1e6;
//head头结点
//idx当前用到的点
//e[manx]当前节点的值
//ne[manx]当前节点指向的下一个位置,即节点的指针。
int head, idx, e[manx], ne[manx];
void yuuka()//初始化(如果你要问为什么叫yuuka,请搜索早濑优香)
{
	head = -1, idx = 0;//-1空集
}
void add_h_yuuka(int x)//插入头结点
{
	e[idx] = x;
	ne[idx] = head;//与头结点互换指针,以前head指向的现在变为插入的ne[idx]接手
	head = idx;
	idx++;//向下一个节点移动
}
void addyuuka(int k, int x)//在节点k后插入
{
	e[idx] = x;
	ne[idx] = ne[k];
	ne[k] = idx;//同理
	idx++;
}
void yadayo(int k)
{
	ne[k] = ne[ne[k]];//把指向k节点的指针指向k所指的节点,即略过了k,产生了删除操作。
}
int main()
{
	int t;
	cin >> t;
	yuuka();
	while (t--)
	{
		char s;
		cin >> s; int cnt, ans;
		if (s == 'H')
		{
			cin >> cnt;
			add_h_yuuka(cnt);
		}
		else if (s == 'D')
		{
			cin >> cnt;
			if (cnt == 0)
			{
				head = ne[head];
			}
			else
			{
				yadayo(cnt - 1);
			}
		}
		else if (s == 'I')
		{
			cin >> cnt >> ans;
			addyuuka(cnt - 1, ans);
		}

	}
	for (int i = head; i != -1; i = ne[i]) cout << e[i] << ' ';
	cout << endl;
}

其实为了防止我忘了才写的😋

# 题目重述 设计算法:仅用一个辅助结点,完成下列要求。 (2)数组 `[a₁, a₂, ..., aₙ, b₁, b₂, ..., bₙ]` 调整为 `[b₁, b₂, ..., bₙ, a₁, a₂, ..., aₙ]`,使用**单链表**完成。 # 给出答案(答案为带注释的代码块) ```c #include <stdio.h> #include <stdlib.h> // 单链表结点定义 typedef struct ListNode { int data; struct ListNode *next; } ListNode, *LinkList; // 创建新结点 ListNode* CreateNode(int value) { ListNode* node = (ListNode*)malloc(sizeof(ListNode)); node->data = value; node->next = NULL; return node; } // 将数组 [a1..an, b1..bn] 构造成单链表 LinkList BuildList(int n) { LinkList head = NULL, tail = NULL; int val = 1; // 输入模拟:构造 a1,a2,...,an,b1,b2,...,bn 的链表 for (int i = 0; i < 2*n; i++) { ListNode* node = CreateNode(val++); if (!head) { head = tail = node; } else { tail->next = node; tail = node; } } return head; } // 核心算法:使用单链表将 an+1~a2n 移动到前面 LinkList RearrangeAB(LinkList L, int n) { if (!L || !L->next || 2*n <= 1) return L; ListNode *slow = L; ListNode *fast = L; // 快慢指针找到中间位置(第 n 个结点为 an) for (int i = 1; i < n && fast && fast->next; i++) { slow = slow->next; fast = fast->next->next; } // 此时 slow 指向 an(第一个 b 前一个),newHead 指向 b1 ListNode *newHead = slow->next; if (!newHead) return L; // 无 b 段 // 断开 a 段与 b 段 slow->next = NULL; // 找到 b 段末尾 bn ListNode *tail = newHead; while (tail->next) { tail = tail->next; } // 将 a 段接到 b 段后面 tail->next = L; // 返回新头 b1 return newHead; } // 打印链表 void PrintList(LinkList L) { while (L) { printf("%d ", L->data); L = L->next; } printf("\n"); } ``` # 代码解析 1. **构建初始链表**:按顺序创建包含 $2n$ 个元素的单链表,前 $n$ 个为 $a_i$,后 $n$ 个为 $b_i$。 2. **快慢指针定位分割点**:`slow` 指针最终指向第 $n$ 个结点(即 $a_n$),其后继就是 $b_1$。 3. **断开连接**:将 `slow->next` 设为 `NULL`,断开两段。 4. **重新链接**:将原后半段($b_1$ 开始)的末尾连接到原前半段头部($a_1$)。 5. **返回新头**:返回 `newHead`(即 $b_1$)作为新链表起点。 整个过程仅使用常量个额外指针变量,符合“仅用一个辅助结点”的广义理解(空间复杂度 $O(1)$)。 # 知识点(列出该代码中遇到的知识点) - **单链表的分割与重组**:通过修改指针将链表拆分为两部分并重新拼接。 - **快慢指针找中点**:用于在不使用下标的情况下定位链表中点。 - **指针操作与边界控制**:正确处理链表断开、连接及空指针异常。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值