C++反转链表之原地反转

•  分别在类内类外通过传递对象或者对象的成员变量进行操作
  • 类内：直接传递对象或者成员变量
  • 类外：传递对象或者成员变量时，涉及到对类内定义的私有成员变量的访问，需要将类外声明的函数在类内部定义为友元函数（friend方法）
    • friend方法：用于定义友元函数或友元类，它允许外部函数或者类直接访问另一个类的私有成员和保护成员，从而打破封装性原则（将类的成员变量（属性）和成员函数（方法）隐藏在类的内部，不允许外部直接访问，而是通过公共的接口（方法）来交互）
      • 友元函数：一个非成员函数可以通过被声明为类A的友元来访问类A的所有成员，包括私有成员和保护成员。友元函数可以是全局函数或者其它类的成员函数
      • 友元类：一个类A可以被声明为另一个类B的友元，这使得该友元类的所有成员函数都可以访问另一个类的所有成员。
      • 用途：友元函数和友元类的主要用途是为了访问类内部的数据而又不破坏类本身的分装性。
      • 注意事项：使用友元函数和友元类时打破了对象的封装和信息隐藏，增加代码出错的可能性。

#include<iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;

//单链表的实现
struct ListNode{
    ListNode(int data=0):data(data),next(nullptr){};
    int data;
    ListNode *next;
};

class Clink{
public:
    Clink(){
        head = new ListNode();
    }
    ~Clink(){
        //节点的释放
    }
public:
    //链表的尾插法实现
    void InsertTail(int val){
        //先找到链表的尾节点
        ListNode *p = head;
        while(p->next!=nullptr){
            p=p->next;
        }
        //生成新节点
        ListNode *q = new ListNode(val);
        p->next = q;
    }
    //链表的头插法
    void InsertHead(int val){
        //新建要插入的节点
        ListNode *q = new ListNode(val);
        //新建节点q指向头节点指向的next，
        q->next = head->next;
        //头节点指向新建节点
        head->next = q;
    }
    //类的内部实现链表反转
    void Revers3(Clink &link){
        ListNode *A = link.head;
        ListNode *p = link.head->next;
        if(p==nullptr){
            return;
        }
        link.head->next=nullptr;
        while(p!=nullptr){
            ListNode *q = p->next;
            p->next =A->next;
            A->next = p;
            p=q;
        }
    }
    void Revers4(ListNode *head){
        ListNode *p = head->next;
        if(p==nullptr){
            return;
        }
        head->next=nullptr;
        while(p!=nullptr){
            ListNode *q = p->next;
            p->next =head->next;
            head->next = p;
            p=q;
        }
    }
    void show(){
        ListNode *p = head->next;
        while(p!=nullptr){
            cout<<p->data<<"   ";
            p=p->next;
        }
        cout<<endl;
    }
private:
    ListNode *head;
    ListNode *tail;
    friend void Revers1(Clink &link);
    friend int main();
};
//链表的反转,类.对象.实例化的实现方法
    void Revers1(Clink &link){
        ListNode *AA = link.head;
        ListNode *p=link.head->next;
        if(p==nullptr){
            return;
        }
        link.head->next =nullptr;
        while(p!=nullptr){
            ListNode *q = p->next;
            p->next = AA->next;
            AA->next =p;
            p=q;
        }
    }
    //链表的反转,指针直接操作的实现方法
    void Revers2(ListNode *head){
        //ListNode *AA = link.head;
        ListNode *p=head->next;
        if(p==nullptr){
            return;
        }
        head->next =nullptr;
        while(p!=nullptr){
            ListNode *q = p->next;
            p->next = head->next;
            head->next =p;
            p=q;
        }
    }
int main(){
    Clink link;
    srand(time(0));
    for(int i=0;i<10;i++){
        int val = rand()%100;
        link.InsertHead(val);
    }
    link.show();
    Revers1(link);
    link.show();
    ListNode *p = link.head;//link类中的head是私有成员变量，需要将main函数设置为类的友元函数从而进行访问
    Revers2(p);
    link.show();
    link.Revers3(link);
    link.show();
    link.Revers4(link.head);
    link.show();
}