链表相关操作：创建链表、遍历链表、求链表长度、链表中删除一个节点、链表中插入一个节点、反转单链表

#include<iostream>
#include<stdlib.h>

typedef struct node
{
    int data;
    struct node *next;
}Node,*pNode;

pNode Creat_list();//创建一个单链表
void Traverse_list(pNode head);//遍历链表
int Len_list(pNode head);//求链表长度
bool Delete_list(pNode head,int n,int &a);//删除链表的第n个节点，并将所删除节点的值传入a中
bool Insert_list(pNode head,int n,int a);//在链表的第n个节点前插入一个新的节点，且新节点的值为n
bool Reverse_list(pNode head);//反转单链表


using namespace std;

int main()
{
    int delval;
    int length=0;
    pNode listhead=Creat_list();
    cout<<"链表元素为：";
    Traverse_list(listhead);

    cout<<endl;
    length=Len_list(listhead);
    cout<<"链表长度为："<<length<<endl;
    cout<<endl;

    
    Delete_list(listhead,2,delval);
    cout<<"删除后链表元素为：";
    Traverse_list(listhead);
    cout<<"被删除的元素的值是："<<delval;
    cout<<endl;
    
    
    Insert_list(listhead,1,2);
    cout<<"插入后链表元素为：";
    Traverse_list(listhead);
    cout<<endl;

    
    cout<<endl;
    Reverse_list(listhead);
    cout<<"反转后链表元素为：";
    Traverse_list(listhead);
    cout<<endl;
    
    cout<<endl;
    return 0;
}



//创建一个包含n个节点的单链表（不包括头结点）
pNode Creat_list()
{
    int n;//所创建链表元素的个数
    pNode head=(pNode)malloc(sizeof(Node));//创建链表的头结点
    head->next=NULL;
    cout<<"Please input the number of list element:";
    cin>>n;
    cout<<endl;

    if(n<=0)
    {
        return NULL;
    }
        
    else
    {
        pNode midnode=(pNode)malloc(sizeof(Node));
        midnode=head;

        for(int i=1;i<n+1;i++)
        {
            int a;
            cout<<"Please input the number"<<i<<"'s data:";
            cin>>a;

            pNode newnode=(pNode)malloc(sizeof(Node));
            if(newnode==NULL)
            {
                cout<<"创建新节点失败"<<endl;
                return NULL;
            }

            else
            {
                midnode->next=newnode;//现在的midnode指向的是newnode的上一个节点
                newnode->data=a;
                newnode->next=NULL;
                midnode=newnode;//现在的midnode指向最新的节点
            }
        }
        
        return head;
    }
}



//遍历链表
void Traverse_list(pNode head)
{
    if(head->next == NULL)
    {
        cout<<"链表为空"<<endl;
        return;
    }

    else
    {
        pNode midnode=(pNode)malloc(sizeof(Node));
        midnode=head;

        while(midnode->next != NULL)
        {
            midnode=midnode->next;
            cout<<midnode->data<<" ";
        }
        cout<<endl;

        return;
    }
}


//求链表长度
int Len_list(pNode head)
{
    int len=0;

    if(head->next==NULL)
    {
        return 0;
    }

    else
    {
        pNode midnode=(pNode)malloc(sizeof(Node));

        if(midnode==NULL)
        {
            cout<<"分配中间节点内存失败！";
            return 0;
        }

        midnode=head;
        while(midnode->next != NULL)
        {
            midnode=midnode->next;
            len++;
        }
        return len;
    }
}



//删除链表中的第n个节点(头结点视为链表的第0个节点)，并返回所删除元素的值到a中
bool Delete_list(pNode head,int n,int &a)
{
    int length=Len_list(head);//链表的长度

    if(n<=0 || n>length)
    {
        cout<<"被删除元素的序数非法！"<<endl;
        return false;
    }

    else if(n==1)
    {
        pNode midnode=(pNode)malloc(sizeof(Node));
        midnode=head->next;
        a=midnode->data;
        head->next=midnode->next;
        free(midnode);

        return true;
    }


    else
    {
        int i=0;

        pNode midnode1=(pNode)malloc(sizeof(Node));
        midnode1=head;

        while(i<n-1)
        {
            midnode1=midnode1->next;
            i++;
        }//出while循环时，midnode指向的是第n-1个节点

        pNode midnode2=(pNode)malloc(sizeof(Node));
        midnode2=midnode1->next;//midnode2是被删除的节点
        a=midnode2->data;
        midnode1->next=midnode2->next;
        free(midnode2);

        return true;
    }
}


//在链表中第n个节点前插入一个值为a的新节点
bool Insert_list(pNode head,int n,int a)
{
    int len=Len_list(head);

    if(n<=0 || n>len)
    {
        cout<<"插入元素的位置非法！";
        return false;
    }

    else if(n==1)
    {
        pNode midnode=(pNode)malloc(sizeof(Node));
        if(midnode==NULL)
        {
            cout<<"分配中间节点内存失败！";
            return false;
        }

        midnode->data=a;
        midnode->next=head->next;
        head->next=midnode;

        return true;
    }

    else
    {
        int i=0;

        pNode midnode1=(pNode)malloc(sizeof(Node));
        if(midnode1==NULL)
        {
            cout<<"分配中间节点内存失败！";
            return false;
        }

        midnode1=head;
        while(i<n-1)
        {
            midnode1=midnode1->next;
            i++;
        }//出while循环时midnode1指向的是第n-1个节点
        

        pNode midnode2=(pNode)malloc(sizeof(Node));
        if(midnode2==NULL)
        {
            cout<<"分配新节点内存失败！";
            return false;
        }
    
        midnode2->data=a;
        midnode2->next=midnode1->next;
        midnode1->next=midnode2;

        return true;
    }
}


//反转单链表
bool Reverse_list(pNode head)
{
    int len=Len_list(head);

    if(len==0 || len==1)
    {
        cout<<"链表元素过少，不能反转！";
        return false;
    }

    else
    {
        pNode midnode1=(pNode)malloc(sizeof(Node));
        pNode midnode2=(pNode)malloc(sizeof(Node));
        if(midnode1==NULL || midnode2==NULL)
        {
            cout<<"分配中间节点内存失败！";
            return false;
        }

        midnode1=head->next;
        midnode2=midnode1->next;
        midnode1->next=NULL;

        while(midnode2->next != NULL)
        {
            pNode X=midnode2->next;
            midnode2->next=midnode1;
            midnode1=midnode2;
            midnode2=X;
        }
        midnode2->next=midnode1;
        head->next=midnode2;

        return true;
    }
}