使用单链表的其他方法实现该代码，代码调换顺序的规则不变：#ifndef NULL #define NULL 0 #endif #include using namespace std; //定义单链表结点结构 struct LNode { int data; LNode* next; LNode() {}; LNode(int e, LNode* n = NULL) :data(e), next(n) {}; }; //单链表list类创建 class Li...-Go服务器开发

以下是使用另一种方法实现该代码的修改版：

#ifndef NULL
#define NULL 0
#endif

#include<iostream>
using namespace std;

// 定义单链表结点结构
struct LNode {
	int data;
	LNode* next;
	LNode() {};
	LNode(int e, LNode* n = NULL) :data(e), next(n) {};
};

// 单链表List类创建
class List {
protected:
	LNode* head;
	int _size;
	void init() {
		head = new LNode;
		head->next = NULL;
		_size = 0;
	}
public:
	// 构造函数
	List(){init();}
	
	// 析构函数
	~List() {
		LNode* p = head;
		while (head) {
			p = p->next;
			delete head;
			head = p;
		}
	}

	// 头节点
	List(int info) { // 使用头结点储存某些信息，不随链表插入改变位置
		init();
		head->data = info;
	}

	int& info() { return head->data; } // 返回链表头结点的信息

	void insert(int& e) {
        _size++;
        LNode* p = new LNode(e, head->next);
        head->next = p;
    }

    void insert(int index, int a) {
        if (index < 1 || index > _size + 1) {
            return; // 无效的插入位置，直接返回
        }

        _size++;

        LNode* prev = nullptr; // 插入位置前一个节点的指针（初始为空）
        LNode* curr = head; // 当前节点的指针

        for (int i = 0; i < index; i++) {
            prev = curr;
            curr = curr->next;
        }

        LNode* newNode = new LNode(a);
        newNode->next = curr;
        
        if (prev != nullptr) {
            prev->next = newNode;
        } else { // 如果是在头部插入，则更新头节点
            head->next = newNode;
        }
    }

	void print_L() {
		LNode* p = head->next;
		while (p != NULL) {
			cout << p->data << " ";
			p = p->next;
		}
		cout << endl;
	}

	int change() {
		int x, y;
		cin >> x >> y;
		
		if (x < 0 || x > _size || y < 0 || y > _size) {
			cout << "error" << endl;
			return -1;
		}

		if (x == y) { // 如果两个位置相同，不进行交换
		    return 0;
	    }
	    
	    LNode* prevX = nullptr; // 第一个要交换的位置的前一个节点
	    LNode* currX = head; // 第一个要交换的位置的当前节点

	    LNode* prevY = nullptr; // 第二个要交换的位置的前一个节点
	    LNode* currY = head; // 第二个要交换的位置的当前节点

	    for (int i = 0; i < x; i++) { // 找到第一个要交换的位置及其前一个节点
	        prevX= currX;
	        currX= currX->next ;
	    }

	    for (int i = 0; i < y; i++) { // 找到第二个要交换的位置及其前一个节点
	        prevY= currY;
	        currY= currY->next ;
	    }

	    if (prevX != nullptr) { // 更新第一个要交换的位置的前一个节点的指针
	        prevX->next = currY;
	    } else { // 如果是头部位置，则更新头节点指针
		    head->next = currY;
		}

	    if (prevY != nullptr) { // 更新第二个要交换的位置的前一个节点的指针
	        prevY->next = currX;
	    } else { // 如果是头部位置，则更新头节点指针
		    head->next = currX;
		}
	    
	    LNode* tmp = currY->next; // 临时保存第二个要交换位置后面节点的指针
	    
	    currY->next = currX->next;
	    currX->next = tmp;

		return 0;
	}
};

int main() {
	List LB;
	int n, a;

	cin >> n;

	for (int i = 0; i < n; i++) {
		cin >> a;
		LB.insert(i + 1, a);
	}

	LB.print_L();

	int t;

	cin >> t;

	for (int i = 0; i < t; i++) {
		int a = LB.change();
		
		if (a == -1)
			continue;
			
		LB.print_L();
	}	
}

这段代码使用了另一种插入和交换方式来实现，但保持了原始功能不变。

内容由零声教学AI助手提供，问题来源于学员提问