单向链表的简单操作(C++实现）

单向链表增查删改的一些简单操作

list.h

#include<iostream>
using namespace std;

typedef int dataType;

class node{
public:
    int data;
    node* next;
};

class list{
public:
    node* head;
    int lengt;
    list();
    list(const list&);
    list& operator=(const list&);
    int list_size() const;
    node* find(dataType);
    void add_front(dataType);
    void add_tail(dataType);
    void add_pos_after(dataType,node*);
    void add_pos_front(dataType,node*);
    void delet(dataType);
    void delet_repeat();
    void delet_after(node*);
    void delet_front(node*);
    void reverse();
    void sort();
    void display() const;
    ~list() = default;
};

list::list(){
    this->head = new node;
    this->head->next = nullptr;
    this->lengt = 0;
}

list::list(const list& l2){
    this->head = new node;
    this->head->next = nullptr;
    node* p2 = l2.head;
    while(p2!=nullptr){
        int x;
        x = p2->data;
        this->add_tail(x);
        p2 = p2->next;
    }
}

list& list::operator=(const list& right){
    static list l2;
    l2.head = new node;
    node* p2 = right.head;
    while(p2!=nullptr){
        int x;
        x = p2->data;
        l2.add_tail(x);
        p2 = p2->next;
    }
    return l2;
}

int list::list_size() const{
    return this->lengt;
}

node *list::find(dataType x) {
    node* pre = this->head->next;
    for(;pre!=nullptr;pre=pre->next){
        if(pre->data==x) return pre;
    }
    return nullptr;
}

void list::add_front(dataType x){
    node* p = new node;
    p->data = x;
    p->next = head->next;
    head->next = p;
    this->lengt++;
}

void list::add_tail(dataType x){
    node* pre = this->head;
    while(pre->next!=nullptr) pre = pre->next;
    node* p = new node;
    p->data = x;
    p->next = nullptr;
    pre->next = p;
    this->lengt++;
}

void list::add_pos_after(dataType x,node* p) {
    node* p_add = new node;
    p_add->data = x;
    p_add->next = p->next;
    p->next = p_add;
    this->lengt++;
}

void list::add_pos_front(dataType x, node *p) {
    node* pre = head;
    while(pre->next!=p) pre = pre->next;
    node* p_add = new node;
    p_add->data = x;
    p_add->next = pre->next;
    pre->next = p_add;
    this->lengt++;
}

void list::delet(dataType x) {
    node* p = head->next;
    node* pre = head;
    while(p->data!=x){
        pre = pre->next;
        p = p->next;
    }
    pre->next = p->next;
    delete p;
}

void list::delet_repeat(){
    int* a = new int[this->lengt];
    node* p = this->head->next;
    node* pre = this->head;
    int temp_len = 0;
    while(p!=nullptr){
       int flag = 1;
        for(int i=0;i<temp_len;++i){
            if(a[i]==p->data){
                node* temp = p;
                p = p->next;
                pre->next = p;
                flag = 0;
                delete temp;
                break;
            }

        }
        if(flag == 0) continue;
        else{
            a[temp_len] = p->data;
            temp_len++;
            p = p->next;
            pre = pre->next;
        }

    }
    delete []a;
}

void list::delet_after(node *p) {
    node* temp = p->next;
    p->next = temp->next;
    delete temp;
}

void list::delet_front(node *p) {
    node* prepre = head;
    node* pre = head->next;
    while(pre->next!=p){
        prepre = prepre->next;
        pre = pre->next;
    }
    prepre->next = p;
    delete pre;
}

void list::reverse(){
    list l2;
    node* pre = this->head->next;
    while(pre!=nullptr){
        int x;
        x = pre->data;
        l2.add_front(x);
        pre = pre->next;
    }
    pre = this->head->next;
    node* pre2 = l2.head->next;
    for(;pre2!=nullptr;pre=pre->next,pre2=pre2->next){
        pre->data = pre2->data;
    }
}

void list::sort() {
    int templen = this->lengt-1;
    node* p = this->head->next;
    for(int i=0;i<this->lengt;++i){
        for(int j=templen;j>=1;--j,p = p->next){
            if((p->data)>(p->next->data)){
                int temp = p->next->data;
                p->next->data = p->data;
                p->data = temp;
            }
        }
        p = this->head->next;
    }
}

void list::display() const{
    node* p = this->head->next;
    while(p!=nullptr){
        cout<<p->data<<" ";
        p = p->next;
    }
    cout<<endl;
}

main.cpp

#include <iostream>
#include"list.h"
using namespace std;

int main() {
    list a1,a2,b,c;
    dataType data;
    //正向和逆向建链测试
    //输入2 ,6, 7, 3, 5, 9,12, 4 ,0
    while(cin>>data){
        if(data==0) break;//输入0结束
        a1.add_front(data);
        a2.add_tail(data);
    }
    a1.display();
    a2.display();
    //链表转置测试
    //输入2 ,16, 3, 8, 15, 4, 9, 7 ,0
    while(cin>>data) {
        if(data==0) break; //输入0结束
        b.add_tail(data);
    }
    b.display();
    b.reverse();
    b.display();
    a1.sort(); //测试升序排序
    a1.display();
    b.add_tail(16);
    b.add_tail(3);
    b.display();
    b.delet_repeat();
    b.display();
    node* pos=b.find(15);
    b.add_pos_after(18,pos);
    b.display();
    b.add_pos_front(23,pos);
    b.display();
    b.delet_after(pos);
    b.display();
    b.delet_front(pos);
    b.display();
    b.delet(8);
    b.display();
    return 0;
}