B. DS单链表--结点交换

B. DS单链表--结点交换
时间限制
1s
内存限制
128MB
题目描述

用C++实现含头结点的单链表，然后实现单链表的两个结点交换位置。

注意不能简单交换两个结点包含数据，必须通过修改指针来实现两个结点的位置交换

交换函数定义可以参考：

swap（int  pa, int pb)  //pa和pb表示两个结点在单链表的位置序号

swap (ListNode * p, ListNode * q)  //p和q表示指向两个结点的指针


输入

第1行先输入n表示有n个数据，接着输入n个数据

第2行输入要交换的两个结点位置

第3行输入要交换的两个结点位置


输出

第一行输出单链表创建后的所有数据，数据之间用空格隔开

第二行输出执行第1次交换操作后的单链表数据，数据之间用空格隔开

第三行输出执行第2次交换操作后的单链表数据，数据之间用空格隔开

如果发现输入位置不合法，输出字符串error，不必输出单链表



输入样例1 
5 11 22 33 44 55
1 4
2 6

输出样例1
11 22 33 44 55 
44 22 33 11 55 
error

提示

注意要用链表实现哦！

注意这里的交换不能只是简单的交换数值 

核心代码如下：

• 先判断参数的正确性
• 在通过方法LL_index(i)得到第i个元素的指针，我们利用该方法得到要交换的两个元素以及它们的前后结点的指针

int LinkList::swap(int i, int j) {
	if (!((i >= 1 && i <= len) && (j >= 1 && j <= len))) {
		return error;
	}
	ListNode* a = this->LL_index(i);
	ListNode* b = this->LL_index(j);
	ListNode* c = this->LL_index(i - 1);
	ListNode* d = this->LL_index(j - 1);
	ListNode* e = this->LL_index(i + 1);
	ListNode* f = this->LL_index(j + 1);
	c->next = b;
	b->next = e;
	d->next = a;
	a->next = f;

	return ok;
}

如图原本的走向是caebdf,通过改变指针的指向后我们便实现了交换a和b

完整代码如下：

#include<iostream>
#include<cstdlib>
using namespace std;
#define ok 0;
#define error -1;

class ListNode {
public:
	int data;
	ListNode* next;
	ListNode() { next = NULL; }
};

class LinkList {
public :
	ListNode* head;
	int len;
	LinkList();
	~LinkList();
	ListNode* LL_index(int i);
	int LL_get(int i);
	int LL_insert(int i, int item);
	int LL_del(int i);
	void LL_display();

	int swap(ListNode* p, ListNode* q);

	int swap(int i, int j);

	int LL_merge(ListNode* La, ListNode* Lb);
};

int LinkList::LL_merge(ListNode* La, ListNode* Lb) {
	ListNode* Lc = La;
	if (!(La && Lb)) {
		return error;
	}
	ListNode* pa = La->next;
	ListNode* pb = Lb->next;
	ListNode* pc = Lc;
	while (pa && pb) {
		if (pa->data < pb->data) {
			pc->next = pa;
			pc = pc->next;
			pa = pa->next;
		}
		else {
			pc->next = pb;
			pc = pc->next;
			pb = pb->next;
		}
	}
	pc->next = pa ? pa : pb;
	head = Lc;
	//len????
	//free(Lb);
	Lb->next = NULL;
	return ok;
}

int LinkList::swap(int i, int j) {
	if (!((i >= 1 && i <= len) && (j >= 1 && j <= len))) {
		return error;
	}
	ListNode* a = this->LL_index(i);
	ListNode* b = this->LL_index(j);
	ListNode* c = this->LL_index(i - 1);
	ListNode* d = this->LL_index(j - 1);
	ListNode* e = this->LL_index(i + 1);
	ListNode* f = this->LL_index(j + 1);
	c->next = b;
	b->next = e;
	d->next = a;
	a->next = f;

	return ok;
}



ListNode* LinkList::LL_index(int i) {
	if (i == 0) {
		return head;
	}
	if(!(i >= 1 && i <= len)){
		return NULL;
	}
	ListNode* p = head->next;
	int j = 1;
	while (p&&j<i) {
		p = p->next;
		j++;
	}
	return p;
}

int LinkList::LL_get(int i) {
	if (!(i >= 1 && i <= len)) {
		return error;
	}
	ListNode* p = head->next;
	int j = 1;
	while (p && j < i) {
		p = p->next;
		j++;
	}
	return p->data;
}

int LinkList::LL_insert(int i, int item) {
	ListNode* node = new ListNode();
	node->data = item;
	if (!(i >= 1 && i <= len+1)) {
		return error;
	}
	//先找到第i-1个结点
	ListNode* p = head;
	int j = 0;
	while (p && j < i - 1) {
		p = p->next;
		j++;
	}
	//核心
	node->next = p->next;
	p->next = node;
	len++;
	return ok;
}

int LinkList::LL_del(int i) {
	if (!(i >= 1 && i <= len + 1)) {
		return error;
	}
	ListNode* p = head;
	int j = 0;
	while (p->next && j < i - 1) {
		p = p->next;
		j++;
	}
	p->next = p->next->next;
	len--;
	return ok;
}

LinkList::LinkList() {
	head = new ListNode();
	len = 0;
}

LinkList::~LinkList() {
	ListNode* p, * q;
	p = head;
	while (p != NULL) {
		q = p;
		p = p->next;
		delete q;
	}
	len = 0;
	head = NULL;
}

void LinkList::LL_display() {
	ListNode* p;
	p = head->next;
	while (p) {
		cout << p->data << ' ';
		p = p->next;
	}
	cout << endl;
}

//
int main()
{
	int n, item, where,a,b;
	LinkList list;
	cin >> n;
	for (int i = 1; i <= n; i++) {
		cin >> item;
		list.LL_insert(i, item);
	}
	list.LL_display();
	for (int i = 0; i < 2; i++) {
		cin >> a >> b;
		int check = list.swap(a, b);
		if (check == -1) {
			cout << "error" << endl;
		}
		else {
			list.LL_display();
		}
	}
	return 0;
}