链表出现了问题，堆栈已损坏，指针不兼容，求解决

代码：

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"
#include "stdlib.h"
typedef struct
{
    int value;
    struct node* next;
}node;

int creatlistf(node* l, int data[], int length)
{
    node* p;
    if (l)
    {
        l->next = NULL;
        for (int i = 0; i < length; i++)
        {
            p = (node*)malloc(sizeof(node));
            p->value = data[i];
            p->next = l->next;
            l->next = p;
        }
        return 1;
    }
    return 0;
}

int creatlistr(node* l, int data[], int length)
{
    node* r, *p;
    if (l)
    {
        l->next = NULL;
        r = l;
        for (int i = 0; i < length; i++)
        {
            p = (node*)malloc(sizeof(node));
            p->value = data[i];
            printf("%d\t", p->value);
            r->next = p;
            r = p;
        }
        r->next = NULL;
        return 1;
    }
    return 0;
}

void displist(node* l)
{
    node* p;
    if (l)
    {
        p = l;
        while (p->next != NULL)
        {
            p = p->next;
            printf("%d\t", p->value);
        }
    }
}
int main()
{
    node* l;
    l = (node*)malloc(sizeof(node));
    int x[10] = { 1,2,3,4,5,6,7,8,9,10 },STATUS=0;
    STATUS = creatlistf(&l, x, 10);
    displist(&l);
    return 0;
}

具体报错如下（软件为vs），因为是xin shou，希望能点名原因和修改方法，谢谢！翻译是是l的两个堆栈已损坏。

谢谢！

改了三个地方，写注释里了

#define _CRT_SECURE_NO_WARNINGS
#include "stdio.h"
#include "stdlib.h"
typedef struct Node
{
    int value;
    struct Node* next;
}node;
 //定义的链表和节点是两个不同的结构体 ，名字不能一样
//node是链表名，Node是节点名
int creatlistf(node* l, int data[], int length)
{
    node* p;
    if (l)
    {
        l->next = NULL;
        for (int i = 0; i < length; i++)
        {
            p = (node*)malloc(sizeof(node));
            p->value = data[i];
            p->next = l->next;
            l->next = p;
        }
        return 1;
    }
    return 0;
}
 
int creatlistr(node* l, int data[], int length)
{
    node* r, *p;
    if (l)
    {
        l->next = NULL;
        r = l;
        for (int i = 0; i < length; i++)
        {
            p = (node*)malloc(sizeof(node));
            p->value = data[i];
            printf("%d\t", p->value);
            r->next = p;
            r = p;
        }
        r->next = NULL;
        return 1;
    }
    return 0;
}
 
void displist(node* l)
{
    node* p;
    if (l)
    {
        p = l;
        while (p->next != NULL)
        {
            p = p->next;
            printf("%d\t", p->value);
        }
    }
}
int main()
{
    node* l;
    l = (node*)malloc(sizeof(node));
    int x[10] = { 1,2,3,4,5,6,7,8,9,10 },STATUS=0;
    STATUS = creatlistf(l, x, 10);//&号去掉 
    displist(l);//&号去掉 
    return 0;
}
 

#include<iostream>
using namespace std;

typedef int DataType;
#define Node ElemType
#define ERROR NULL

//构建一个节点类
class Node
{
public:
    int data;     //数据域
    Node* next;  //指针域
};

//构建一个单链表类
class LinkList
{
public:
    LinkList();                      //构建一个单链表;
    ~LinkList();                  //销毁一个单链表;
    void CreateLinkList(int n);   //创建一个单链表
    void TravalLinkList();        //遍历线性表
    int GetLength();              //获取线性表长度
    bool IsEmpty();               //判断单链表是否为空
    ElemType* Find(DataType data); //查找节点
    void InsertElemAtEnd(DataType data);            //在尾部插入指定的元素
    void InsertElemAtIndex(DataType data, int n);    //在指定位置插入指定元素
    void InsertElemAtHead(DataType data);           //在头部插入指定元素
    void DeleteElemAtEnd();       //在尾部删除元素
    void DeleteAll();             //删除所有数据
    void DeleteElemAtPoint(DataType data);     //删除指定的数据
    void DeleteElemAtHead();      //在头部删除节点
private:
    ElemType* head;              //头结点
};

//初始化单链表
LinkList::LinkList()
{
    head = new ElemType;
    head->data = 0;               //将头结点的数据域定义为0
    head->next = NULL;            //头结点的下一个定义为NULL
}

//销毁单链表
LinkList::~LinkList()
{
    delete head;                 //删除头结点
}

//创建一个单链表
void LinkList::CreateLinkList(int n)
{
    ElemType* pnew, * ptemp;
    ptemp = head;
    if (n < 0) {       //当输入的值有误时，处理异常
        cout << "输入的节点个数有误" << endl;
        exit(EXIT_FAILURE);
    }
    for (int i = 0; i < n; i++) {        //将值一个一个插入单链表中
        pnew = new ElemType;
        cout << "请输入第" << i + 1 << "个值: ";
        cin >> pnew->data;
        pnew->next = NULL;          //新节点的下一个地址为NULL
        ptemp->next = pnew;         //当前结点的下一个地址设为新节点
        ptemp = pnew;               //将当前结点设为新节点
    }
}

//遍历单链表
void LinkList::TravalLinkList()
{
    if (head == NULL || head->next == NULL) {
        cout << "链表为空表" << endl;
    }
    ElemType* p = head;                 //另指针指向头结点
    while (p->next != NULL)        //当指针的下一个地址不为空时，循环输出p的数据域
    {
        p = p->next;               //p指向p的下一个地址
        cout << p->data << " ";
    }
}

//获取单链表的长度
int LinkList::GetLength()
{
    int count = 0;                  //定义count计数
    ElemType* p = head->next;           //定义p指向头结点
    while (p != NULL)                //当指针的下一个地址不为空时，count+1
    {
        count++;
        p = p->next;                //p指向p的下一个地址
    }
    return count;                   //返回count的数据
}

//判断单链表是否为空
bool LinkList::IsEmpty()
{
    if (head->next == NULL) {
        return true;
    }
    return false;
}

//查找节点
ElemType* LinkList::Find(DataType data)
{
    ElemType* p = head;
    if (p == NULL) {                           //当为空表时，报异常
        cout << "此链表为空链表" << endl;
        return ERROR;
    }
    else
    {
        while (p->next != NULL)               //循环每一个节点
        {
            if (p->data == data) {
                return p;                     //返回指针域
            }
            p = p->next;
        }
        return NULL;                           //未查询到结果
    }
}

//在尾部插入指定的元素
void LinkList::InsertElemAtEnd(DataType data)
{
    ElemType* newNode = new ElemType;    //定义一个Node结点指针newNode
    newNode->next = NULL;         //定义newNode的数据域和指针域
    newNode->data = data;
    ElemType* p = head;              //定义指针p指向头结点
    if (head == NULL) {           //当头结点为空时，设置newNode为头结点
        head = newNode;
    }
    else                          //循环知道最后一个节点，将newNode放置在最后
    {
        while (p->next != NULL)
        {
            p = p->next;
        }
        p->next = newNode;
    }
}

//在指定位置插入指定元素
void LinkList::InsertElemAtIndex(DataType data, int n)
{
    if (n<1 || n>GetLength())                   //输入有误报异常
        cout << "输入的值错误" << endl;
    else
    {
        ElemType* ptemp = new ElemType;        //创建一个新的节点
        ptemp->data = data;                     //定义数据域
        ElemType* p = head;                    //创建一个指针指向头结点
        int i = 1;
        while (n > i)                           //遍历到指定的位置
        {
            p = p->next;
            i++;
        }
        ptemp->next = p->next;                 //将新节点插入到指定位置
        p->next = ptemp;
    }
}

//在头部插入指定元素
void LinkList::InsertElemAtHead(DataType data)
{
    ElemType* newNode = new ElemType;    //定义一个Node结点指针newNode
    newNode->data = data;
    ElemType* p = head;              //定义指针p指向头结点
    if (head == NULL) {           //当头结点为空时，设置newNode为头结点
        head = newNode;
    }
    newNode->next = p->next;          //将新节点插入到指定位置
    p->next = newNode;
}

//在尾部删除元素
void LinkList::DeleteElemAtEnd()
{
    ElemType* p = head;          //创建一个指针指向头结点
    ElemType* ptemp = NULL;      //创建一个占位节点
    if (p->next == NULL) {        //判断链表是否为空
        cout << "单链表空" << endl;
    }
    else
    {
        while (p->next != NULL)   //循环到尾部的前一个
        {
            ptemp = p;            //将ptemp指向尾部的前一个节点
            p = p->next;          //p指向最后一个节点
        }
        delete p;                //删除尾部节点
        p = NULL;
        ptemp->next = NULL;
    }
}

//删除所有数据
void LinkList::DeleteAll()
{
    ElemType* p = head->next;
    ElemType* ptemp = new ElemType;
    while (p != NULL)                    //在头结点的下一个节点逐个删除节点
    {
        ptemp = p;
        p = p->next;
        head->next = p;
        ptemp->next = NULL;
        delete ptemp;
    }
    head->next = NULL;                 //头结点的下一个节点指向NULL
}

//删除指定的数据
void LinkList::DeleteElemAtPoint(DataType data)
{
    ElemType* ptemp = Find(data);    //查找到指定数据的节点位置
    if (ptemp == head->next) {        //判断是不是头结点的下一个节点，如果是就从头部删了它
        DeleteElemAtHead();
    }
    else
    {
        ElemType* p = head;          //p指向头结点
        while (p->next != ptemp)      //p循环到指定位置的前一个节点
        {
            p = p->next;
        }
        p->next = ptemp->next;         //删除指定位置的节点
        delete ptemp;
        ptemp = NULL;
    }

}

//在头部删除节点
void LinkList::DeleteElemAtHead()
{
    ElemType* p = head;
    if (p == NULL || p->next == NULL) {   //判断是否为空表，报异常
        cout << "该链表为空表" << endl;
    }
    else
    {
        ElemType* ptemp = NULL;      //创建一个占位节点
        p = p->next;
        ptemp = p->next;              //将头结点的下下个节点指向占位节点
        delete p;                     //删除头结点的下一个节点
        p = NULL;
        head->next = ptemp;           //头结点的指针更换
    }
}

//测试函数
int main()
{
    LinkList l;
    int i;
    cout << "1.创建单链表   2.遍历单链表   3.获取单链表的长度   4.判断单链表是否为空   5.获取节点\n";
    cout << "6.在尾部插入指定元素   7.在指定位置插入指定元素   8.在头部插入指定元素\n";
    cout << "9.在尾部删除元素   10.删除所有元素   11.删除指定元素   12.在头部删除元素   0.退出" << endl;
    do
    {
        cout << "请输入要执行的操作: ";
        cin >> i;
        switch (i)
        {
        case 1:
            int n;
            cout << "请输入单链表的长度: ";
            cin >> n;
            l.CreateLinkList(n);
            break;
        case 2:
            l.TravalLinkList();
            break;
        case 3:
            cout << "该单链表的长度为" << l.GetLength() << endl;
            break;
        case 4:
            if (l.IsEmpty() == 1)
                cout << "该单链表是空表" << endl;
            else
            {
                cout << "该单链表不是空表" << endl;
            }
            break;
        case 5:
            DataType data;
            cout << "请输入要获取节点的值: ";
            cin >> data;
            cout << "该节点的值为" << l.Find(data)->data << endl;
            break;
        case 6:
            DataType endData;
            cout << "请输入要在尾部插入的值: ";
            cin >> endData;
            l.InsertElemAtEnd(endData);
            break;
        case 7:
            DataType pointData;
            int index;
            cout << "请输入要插入的数据: ";
            cin >> pointData;
            cout << "请输入要插入数据的位置: ";
            cin >> index;
            l.InsertElemAtIndex(pointData, index);
            break;
        case 8:
            DataType headData;
            cout << "请输入要在头部插入的值: ";
            cin >> headData;
            l.InsertElemAtHead(headData);
            break;
        case 9:
            l.DeleteElemAtEnd();
            break;
        case 10:
            l.DeleteAll();
            break;
        case 11:
            DataType pointDeleteData;
            cout << "请输入要删除的数据: ";
            cin >> pointDeleteData;
            l.DeleteElemAtPoint(pointDeleteData);
            break;
        case 12:
            l.DeleteElemAtHead();
            break;
        default:
            break;
        }
    } while (i != 0);

    system("pause");
    return 0;
}

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <stdlib.h>

typedef struct _node
{
    int value;
    struct _node *next;
} node;

node *create_list(int data[], int length)
{
    node *head = (node *)malloc(sizeof(node));
    head->value = 0;
    head->next = NULL;
    for (int i = 0; i < length; i++)
    {
        node *p = (node *)malloc(sizeof(node));
        p->value = data[i];
        p->next = head->next;
        head->next = p;
    }
    return head;
}

void display_list(node *head)
{
    node *p = head->next;
    while (p)
    {
        printf("%d ", p->value);
        p = p->next;
    }
    printf("\n");
}

void destroy_list(node *head)
{
    while (head)
    {
        node *p = head;
        head = head->next;
        free(p);
    }
}

int main()
{
    int x[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    node *head = create_list(x, 10);
    display_list(head);
    destroy_list(head);
    return 0;
}