DS单链表--结点交换

题目描述

用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
 

示例代码：

#include <iostream>
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()
    {
        head = new ListNode();
        len = 0;
    }
    ~LinkList() //链表回收
    {
        ListNode* p, * q;
        p = head;
        while (p != NULL)
        {
            q = p;
            p = p->next;
            delete q;
        }
        len = 0;
        head = NULL;
    }
    ListNode* LL_index(int i) //返回指针
    {
        int j = 0;
        ListNode* p;
        p = head;
        while (p && j < i - 1) //寻找第i个结点，并让p指向其前驱
        {
            p = p->next;
            ++j;
        }
        if (!p || j > i - 1)  //p==NULL，返回的位置不合理
        {
            return NULL;
        }
        else
        {
            return p;
        }
    }
    int LL_insert(int i, int item) //插入结点
    {
        ListNode* p;
        if (LL_index(i) == NULL)
        {
            return error;
        }
        else
        {
            p = LL_index(i);
        }
        ListNode* s;
        s = new ListNode();
        s->data = item;
        s->next = p->next;
        p->next = s;
        len++;
        return ok;
    }
    void LL_display()
    {
        ListNode* p = new ListNode();
        p = head->next;
        while (p != NULL)
        {
            cout << p->data << ' ';
            p = p->next;
        }
        cout << endl;
    }
    int swap(int pa, int pb)
    {
        if (pa < 1 || pb < 1 || pa>len || pb>len) //要交换的位置无效
        {
            return error;
        }
        else
        {
            ListNode* p, * q;
            p = LL_index(pa); //即pa的前驱
            q = LL_index(pb);
            //交换前驱结点
            ListNode* temp;
            temp = p->next;
            p->next = q->next;
            q->next = temp;
            //交换后继结点
            temp = p->next->next;
            p->next->next = q->next->next;
            q->next->next = temp;
            return ok;
        }
    }
};
int main()
{
    int n;
    int data;
    LinkList list;
    cin >> n;
    for (int i = 1;i <= n;i++)
    {
        cin >> data;
        list.LL_insert(i, data);
    }
    list.LL_display();
    int pos1, pos2, pos3, pos4;
    cin >> pos1 >> pos2;
    if (list.swap(pos1, pos2) != -1) //如果交换的位置有效
    {
        list.LL_display();
    }
    else
    {
        cout << "error" << endl;
    }
    cin >> pos3 >> pos4;
    if (list.swap(pos3, pos4) != -1)
    {
        list.LL_display();
    }
    else
    {
        cout << "error" << endl;
    }
    return 0;
}

 改变前驱结点和后驱结点，就相当于把一个新的结点换在了原来的位置