zoukankan      html  css  js  c++  java
  • 基础数据结构-线性表-单链表的结点交换

    实现单链表,含头结点
    属性包括:data数据域、next指针域
    操作包括:插入、删除、查找
    注意:单链表不是数组,所以位置从1开始对应首结点,头结点不放数据
    输入
    n
    第1行先输入n表示有n个数据,接着输入n个数据
    第2行输入要插入的位置和新数据
    第3行输入要插入的位置和新数据
    第4行输入要删除的位置
    第5行输入要删除的位置
    第6行输入要查找的位置
    第7行输入要查找的位置
    输出
    n
    数据之间用空格隔开,
    第1行输出创建后的单链表的数据
    每成功执行一次操作(插入或删除),输出执行后的单链表数据
    每成功执行一次查找,输出查找到的数据
    如果执行操作失败(包括插入、删除、查找等失败),输出字符串error,不必输出单链表
    样例输入
    6 11 22 33 44 55 66
    3 777
    1 888
    1
    11
    0
    5
    样例输出
    11 22 33 44 55 66
    11
    22 777 33 44 55 66
    888
    11 22 777 33 44 55 66
    11 22 777 33 44 55 66
    error
    error
    44

    #include<iostream>  
    using namespace std;  
        
    #define ok 1  
    #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(int  pa, int pb); 
        int swap(ListNode *p,ListNode *q); 
    };  
        
    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; 
        cout<<p->data; 
        p=p->next; 
        while(p)  
        { 
            cout<<" "<<p->data; 
            p=p->next;  
        }  
        cout<<endl;  
    }  
        
    ListNode* LinkList::LL_index(int i)  
    {  
        if(i<0||i>len)return NULL; 
        if(i==0)return head; 
        ListNode *p;  
        p=head->next;  
        while(p->next && --i)  
        {  
            p=p->next;  
        } 
        return p;  
    }  
        
    int LinkList::LL_get(int i)  
    {  
        if(i<1||i>len)return error;  
        return LL_index(i)->data; 
    }  
        
    int LinkList::LL_insert(int i,int item)  
    {  
        if(i<1||i>len+1)return error;  
        ListNode *p; 
        p=new ListNode; 
        p->data=item; 
        if(i==len+1) 
        { 
            LL_index(len)->next=p; 
            len++; 
            return ok; 
        } 
        else
        { 
            ListNode *pNex,*pPre; 
            pNex=LL_index(i-1); 
            pPre=LL_index(i); 
            pNex->next=p; 
            p->next=pPre; 
            len++; 
            return ok;  
        } 
    }  
        
    int LinkList::LL_del(int i)  
    {  
        if(i<1||i>len)return error;  
        ListNode *pNex,*pPre; 
        pNex=LL_index(i-1); 
        pPre=LL_index(i+1); 
        pNex->next=pPre; 
        len--; 
        return ok; 
    }  
      
    int LinkList::swap(int  pa, int pb) 
    { 
        if(pa<1||pa>len||pb<1||pb>len)return error; 
        ListNode *a_pNex,*a,*a_pPre,*b_pNex,*b,*b_pPre; 
        a_pNex=LL_index(pa-1); 
        a=LL_index(pa); 
        a_pPre=LL_index(pa+1); 
        b_pNex=LL_index(pb-1); 
        b=LL_index(pb); 
        b_pPre=LL_index(pb+1); 
      
        if(a->next==b) 
        { 
            a_pNex->next=b; 
            b->next=b_pNex; 
            b_pNex->next=b_pPre; 
            return ok; 
        } 
        if(b->next==a) 
        { 
            b_pNex->next=a; 
            a->next=a_pNex; 
            a_pNex->next=a_pPre; 
            return ok; 
        } 
        a_pNex->next=b; 
        b->next=a_pPre; 
        b_pNex->next=a; 
        a->next=b_pPre; 
        return ok; 
    } 
    //改变指针进行交换
    int LinkList::swap(ListNode *p,ListNode *q) 
    { 
        if(p==head||q==head||!p||!q)return error; 
        ListNode *a_pNex,*a,*a_pPre,*b_pNex,*b,*b_pPre; 
        a=p; 
        a_pPre=p->next; 
        b=q; 
        b_pPre=q->next; 
      
        a_pNex=head; 
        b_pNex=head; 
        while(a_pNex->next!=p)  
        {  
            a_pNex=a_pNex->next;  
        } 
         while(b_pNex->next!=q)  
        {  
            b_pNex=b_pNex->next;  
        } 
      
        if(a->next==b) 
        { 
            a_pNex->next=b; 
            b->next=b_pNex; 
            b_pNex->next=b_pPre; 
            return ok; 
        } 
          
        if(b->next==a) 
        { 
            b_pNex->next=a; 
            a->next=a_pNex; 
            a_pNex->next=a_pPre; 
            return ok; 
        } 
          
        a_pNex->next=b; 
        b->next=a_pPre; 
        b_pNex->next=a; 
        a->next=b_pPre; 
        return ok; 
    } 
     /*改变数值进行交换
    int LinkList::swap(ListNode *p,ListNode *q) 
    { 
        if(p==head||q==head||!p||!q)return error; 
        int temp;
        temp=p->data;
        p->data=q->data;
        q->data=temp;
        return ok; 
    }
    */
      
    int main()  
    {  
       int n,i,NUM,num1,num2;   
        LinkList L;   
    //第1行先输入n表示有n个数据,即n是实际长度;接着输入n个数据   
        cin>>n;   
        for(i=0;i<n;i++)   
        {   
            cin>>NUM;   
            L.LL_insert(i+1,NUM);   
        }    
        if(n!=0)L.LL_display();  
    //第2行输入要交换的两个结点位置 
        cin>>num1>>num2; 
        if(L.swap(num1,num2)==-1)cout<<"error"<<endl; 
        else L.LL_display(); 
    //第3行输入要交换的两个结点位置 
        cin>>num1>>num2; 
        if(L.swap(L.LL_index(num1),L.LL_index(num2))==-1)cout<<"error"<<endl; 
        else L.LL_display(); 
        return 0;   
        
    } 
  • 相关阅读:
    【云栖社区001-数据结构】如何实现一个高效的单向链表逆序输出(Java版)
    全球疫情爬取及展示
    两个命令配置云服务器web开发环境
    云服务器的两类系统特点整理介绍
    团队介绍和项目简介
    Navicat连接阿里云服务器上MySQL数据库
    Android_bilibili式评论及回复的简单实现
    人月神话阅读笔记02
    每日进度博客_2
    每日进度博客_1
  • 原文地址:https://www.cnblogs.com/nathaneko/p/6491273.html
Copyright © 2011-2022 走看看