【id:22】【20分】B. 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 <-复制

输出样例1

提示

注意要用链表实现哦！

#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;
    //listcode类型的指针
    int len;
    LinkList()
    {
        head = new ListNode();
        len = 0;
        //表示整个链表的长度
    }
    ~LinkList()
    {
        ListNode* p, * q;
        p = head;//定义一个空指针先指向第一个节点的地址
        while (p != NULL)
        {
            q = p;
            //指针q指向指针p
            p = p->next;
            //p往后移一位
            delete q;
            //删除前面那个指针
            //直到删除到p为空指针为止
        }
        len = 0;
        head = NULL;
    }
ListNode* LL_index(int i)
//返回第i个节点的指针，如果不存在则返回NULL
{
    if (i - 1 > len || i <= 0)
    {
        return NULL;
    }
    else
    {
        ListNode* p;
        p = head->next;
        for (int j = 1; j < i; j++)
        {
            p = p->next;
            //指向后一个元素
        }
        return p;
    }
}
int LL_get(int i)
{
    if (i > len || i <= 0)
    {
        return error;
    }
    else
    {
        ListNode* p;
        p = head->next;
        for (int j = 1; j < i; j++)
        {
            p = p->next;
            //指向后一个元素
        }
        return p->data;
    }
}
int LL_insert(int i, int item)
{
    if (i - 1 > len || i <= 0)
    {
        return error;
    }
    else
    {
        ListNode* pre = head, * new1, * after;
        ListNode* p = head->next;
        for (int j = 1; j < i; j++)
        {
            pre = p;
            //要得到转换的前一个位置
            p = p->next;
            //p往后一位
        }
        new1 = new ListNode();
        new1->data = item;
        new1->next = p;
        pre->next = new1;
        len++;
        return ok;
    }
}
int LL_del(int i)
{
    if (i - 1 > len || i <= 0)
    {
        return error;
    }
    else
    {
        //完全可以直接指向后两个，直接跳过后面的一个来实现删除，
        //但是代表删除的元素，将会永远存在，并且无法找回并删除
        ListNode* p, * pre = head, * after;
        p = head->next;
        for (int j = 1; j < i; j++)
        {
            pre = p;
            //同样记录前面一个位置
            p = p->next;
        }
        after = p->next;
        //用after记录后一个位置
        p = NULL;
        pre->next = after;
        len--;
        return ok;
    }
}
void LL_display()
{
    ListNode* p;
    p = head->next;
    while (p)
    {
        cout << p->data << ' ';
        p = p->next;
    }
    cout << endl;
}
int swap(int pa, int pb)  //pa和pb表示两个结点在单链表的位置序号
{
    if (pa<1 || pa>len || pb<1 || pb>len|| pa==pb )
    {
        return error;
    }
    else
    {
        ListNode* prea, * p1, * preb, * p2;
        prea = head;
        preb = head;
        p1 = head->next;
        p2 = head->next;
        for (int i = 1; i < pa; i++)
        {
            prea = p1;
            p1 = p1->next;
            //往后移动一位,得到第一个要交换的位置
        }
        for (int i = 1; i < pb; i++)
        {
            preb = p2;
            p2 = p2->next;
            //往后移动一位,得到第二个要交换的位置
        }
        ListNode* t;
        t = prea->next;
        prea->next = preb->next;
        preb->next = t;
        //交换前躯
        t = prea->next->next;
        prea->next->next = preb->next->next;
        preb->next->next = t;
        //交换后继续
        return ok;
    }
}
};
int main()
{
    LinkList p;
    int num;
    int lenth;
    cin >> lenth;
    for (int i = 1; i <= lenth; ++i)
    {
        cin >> num;
        p.LL_insert(i, num);
    }
    p.LL_display();
    int pa, pb;
    cin >> pa >> pb;
    if (p.swap(pa, pb) == 0)
    {
        p.LL_display();
    }
    else
    {
        cout << "error" << endl;
    }
    cin >> pa >> pb;
    if (p.swap(pa, pb) == 0)
    {
        p.LL_display();
    }
    else
    {
        cout << "error" << endl;
    }
    return 0;
}