初试C++单向链表

#include <stdio.h>
#include <string.h>
#include <iostream>
using namespace std;
class Node  //声明节点
{
    int data;       //储存数据
    Node *next; //连接
public: 
    Node():next(NULL){  //构造
    }
    Node(const int i):data(i),next(NULL){
    }
    ~Node(){
    }
    friend class Linked_list;
};
class Linked_list{
    Node *head; //链表首地址
    Node *tail;
public:
    Linked_list():head(NULL),tail(NULL){
    }
    Linked_list(const int *a,const unsigned int length):head(NULL),tail(NULL){      //用数组来构造
        head = new Node(*a);        //  Node *p = new Node(*a);
        Node *p =head;          //  head = p;
        a++;
         for (int i = 1; i < length; ++i)   //sizeof() 判定数组空间
        {
            p->next= new Node( *a); //开空间，构造函数赋初值
            a++;                //数组指针移位
            p = p->next;            //链表指针移动
        }
        tail = p;                   //记录末地址
    }

    Linked_list(const Linked_list &other):head(NULL),tail(NULL){    //拷贝构造
        head = new Node (other.head->data);     //  Node *p = new Node(other.head->data);
        Node *p= head;                  //  head = p;
        Node *t =other.head;                //定义链表指针，从而在函数运行的时候不改变other.head 的值
        t =t->next;
        while(t !=NULL){                //判定是否拷贝
            p->next= new Node( t->data);        
            t = t->next;
            p = p->next;
        }
        tail =p;                        //记录末地址

    }
    ~Linked_list(){        //析构函数
        while(head !=NULL){     //判定
            Node *tem = head;   //定义链表指针，代替head释放空间 
            head = head->next;  
            delete [] tem;
        }
    }
    Linked_list& Print(){       //输出成员函数
        Node *tem = head;   //定义链表指针，代替head移动
        while(tem != NULL){ //判定
            cout << tem->data<<",";
            tem = tem->next;    //指针移位
        }
        cout<<endl;
        return *this;
    }
    Linked_list& Head_add(const int x){
        Node* tem = new Node (x);
        tem->next = head;
        head = tem ;
        // Node* tem =head; //两种写法
        // head =new Node (x);
        // head->next =  tem;
        return *this;
    }
    Linked_list& Pushback(const int x){ //添加一个数
        tail->next = new Node(x);
        tail =tail->next;
        return *this;
    }
    Linked_list& Insert(const unsigned int j,const int x){  //插入一个数，j 决定第几个
        if(j >0 ){
            Node *tem =head;
            for (int i = 1; i < j; ++i)
            {
                tem = tem->next;
                if(tem ->next==NULL)
                    break;          
            }
            Node * p = tem->next;
            tem->next = new Node (x);
            tem = tem ->next; 
            tem ->next= p;
        }
        else if(j==0){
            this ->Head_add(x);
        }
    }
    Linked_list& Revise(const unsigned int j,const unsigned int x){     //修改数据
        Node *tem = head;
        for (int i = 0; i < j-1; ++i)
        {
            tem = tem ->next;
        }
        tem ->data = x;
    }
    Linked_list& Delete(const unsigned int j){      //删除数据
        if(j == 1){
            Node * tem = head;
            head = head->next;
            delete [] tem;
        }
        else{ 
            Node *tem =head;
            for (int i = 1; i < j-1;++i)
            {
                tem = tem ->next;
            }
            Node *p =tem;
            tem ->next = tem ->next->next;
            delete [] p->next;
        }
        return *this;
    }
    Linked_list& Insert(const unsigned int j,const int* a){ //插入数组，算法比较low
        if(j==0){
            this ->Head_add(*a);
        }
        else if(j > 0){
            Node *tem =head;
            for (int i = 1; i < j; ++i)
            {
                tem = tem->next;
                if(tem ->next==NULL)
                    break;          
            }
            Node *p = tem ;
            Node *x =tem ->next;
            for(int i= 0;i<sizeof(a);++i){
                p->next = new Node (*a);    
                p = p->next;
                a++;
            }
            p->next = x;
        }
        return *this;
    }
    Linked_list& Head_add(const int *a){
        Node *tem =head;        
        head = new Node (*a);
        Node *p =head;
        a++;
        for(int i= 1;i<sizeof(a);++i){
            p->next = new Node (*a);    
            p = p->next;
            a++;
        }
        p ->next= tem;
        return *this;   
    }
    Linked_list& Delete(const unsigned int j,const unsigned int x){     //删除多个连续数据
        Node * tem = head;  
        if(j == 1){
            for (int i = 0; i < x; ++i)
            {           
                head = head->next;
                delete [] tem;
                tem = head;
            }

        }
        else{ 
            for (int i = 1; i < j-1;++i)
            {
                tem = tem ->next;
            }
            Node *p =tem;
            for (int i = 0; i < x; ++i)
            {
                tem ->next = tem ->next->next;
                delete [] p->next;
                p = tem ;               
            }
        }
        return *this;
    }
    Linked_list& Pushback(const int *a){    //添加数组
        Node *p = tail;
        for(int i= 0;i<sizeof(a);++i){
            p->next = new Node (*a);    
            p = p->next;
            a++;
        }
        tail =p;
        return *this;
    }
    //排序   BOSS
    Linked_list& Asend(){
        // for (Node *x= head; x->next != NULL; x=x->next)  //只交换值，而没能以Node伟整体排序，
        // {                            //简单地说就是，交换指针和交换值两种层次
        //  for(Node *y=head;y->next !=NULL;y = y->next){
        //      if(y->data>y->next ->data){
        //          int tdata= y->data;
        //          y->data = y->next ->data;
        //          y->next ->data = tdata;
        //      }
        //  }
        // }
        Node *tem= new Node[1];
        tem->next =head;         //算法较low，望大佬指点
        for(Node *x= tem;x ->next!=NULL; x=x->next){
            for(Node *y =tem;y->next->next !=NULL;y=y->next){
                if(y->next->data > y->next->next->data){
                    Node *a = y ;
                    Node *c = y->next;
                    Node *b = y->next->next;
                    Node *d = y->next->next->next;
                    a->next=b;
                    b->next =c;
                    c->next =d;
                    x = a;
                }
            }
        }
        head = tem ->next;
        delete [] tem;
        return *this;
    }
};
    ostream &operator <<(ostream &out,Linked_list& other){
        other.Print();
        return cout;
    } 
int main(){ 
    int a[4] = {4,3,2,1};
    int b [10]= {5,4,3,2,1,10,9,8,7,6};
    Linked_list list1(a,4); 
    Linked_list list2(b,10); 
    list2.Pushback(9);
    list2.Insert(4,b);
    list2.Head_add(a);
    list2.Delete(2,2);
    list2.Pushback(a);
    list2.Revise(9,8);

    list2.Print();
    list2.Asend();
    //cout << list1;
    list2.Print();
    return 0;
}