C 特定情况下的分段故障（堆芯倾倒）

我在练习双链表。在这个项目中，一切似乎都很好。在Delete（）函数中，当我尝试删除第一个节点时，程序运行正常并删除第一个代码。但每当我给任何其他节点我总是得到错误：分段错误（核心转储）。谁能告诉我我做错了什么吗

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

    struct Node{
        struct Node *prev;
        int data;
        struct Node *next; 
    }*first = NULL;

    void create(int A[], int n){
        struct Node *t, *last;
        int i;

        first = (struct Node *)malloc(sizeof(struct Node));
        first->data = A[0];
        first->prev = first->next = NULL;
        last = first;

        for(i = 1; i < n; i++){
            t = (struct Node *)malloc(sizeof(struct Node));
            t->data = A[i];
            t->prev = last->next;
            t->next = NULL;
            last->next = t;
            last = t;
        }
    }   
    void Display(struct Node *p){
        while( p != NULL){
            printf("%d ",p->data);
            p = p->next;
        }
        printf("\n");
    }

    int Length(struct Node *p){
        int len = 0;
        while(p){
            len++;
            p = p->next;
        }
        return len;
    }

    void insert(int index, int key){
        struct Node *t, *p = first;
        int i;

        if(index < 0 || index > Length(p))
            return;
        t = (struct Node *)malloc(sizeof(struct Node));
        t->data = key;
        if(index == 0){
            if(p == NULL){
                t->prev = NULL;
                t->next = NULL;
                first = t;
            }
            else{
                t->prev = NULL;
                t->next = first;
                first->prev = t;
                first = t;
             }
            }
        else{
            for(i = 0; i < index - 1; i++) p = p->next;
            t->next = p->next;
            t->prev = p;
            if(p->next) p->next->prev = t;
            p->next = t;
        }
    }

    int Delete(struct Node *p, int index){
        int x = -1,i;
        if(index < 1 || index > Length(p))
            return -1;

        if(index == 1){
            first = first->next;
            if(first)first->prev = NULL;
            x = p->data;
            free(p);
        }
        else{
            for(i=0; i<index-1; i++)
            p=p->next;
            x=p->data;
            p->prev->next=p->next;
             if(p->next)
             p->next->prev=p->prev;
            free(p);
         }   
        return x;
    }

    void main(){
        int A[] = {2, 4, 6, 8, 10};
        create(A, 5);
        Display(first);
        printf("%d is deleted\n",Delete(first, 3));
        Display(first);
    }

#包括
#包括
结构节点{
结构节点*prev；
int数据；
结构节点*下一步；
}*第一个=空；
无效创建（int A[]，int n）{
结构节点*t，*last；
int i；
first=（结构节点*）malloc（sizeof（结构节点））；
第一->数据=A[0]；
first->prev=first->next=NULL；
最后=第一；
对于（i=1；idata=A[i]；
t->prev=last->next；
t->next=NULL；
last->next=t；
last=t；
}
}   
无效显示（结构节点*p）{
while（p！=NULL）{
printf（“%d”，p->data）；
p=p->next；
}
printf（“\n”）；
}
整数长度（结构节点*p）{
int len=0；
while（p）{
len++；
p=p->next；
}
回程透镜；
}
无效插入（整数索引，整数键）{
结构节点*t，*p=first；
int i；
如果（指数<0 | |指数>长度（p））
返回；
t=（结构节点*）malloc（sizeof（结构节点））；
t->data=key；
如果（索引==0）{
if（p==NULL）{
t->prev=NULL；
t->next=NULL；
第一个=t；
}
否则{
t->prev=NULL；
t->next=第一；
第一->上一个=t；
第一个=t；
}
}
否则{
对于（i=0；inext；
t->next=p->next；
t->prev=p；
如果（p->next）p->next->prev=t；
p->next=t；
}
}
int Delete（结构节点*p，int索引）{
int x=-1，i；
如果（指数<1 | |指数>长度（p））
返回-1；
如果（索引==1）{
第一个=第一个->下一个；
如果（第一个）第一->上一个=空；
x=p->数据；
自由基（p）；
}
否则{
对于（i=0；不精确；
x=p->数据；
p->prev->next=p->next；
如果（p->next）
p->next->prev=p->prev；
自由基（p）；
}   
返回x；
}
void main（）{
inta[]={2,4,6,8,10}；
创建（A，5）；
显示（第一）；
printf（“%d已删除”\n“，删除（第一，3））；
显示（第一）；
}

索引有问题

显然你希望第一个索引是1-好的

让我们调用索引为2的函数

因此，您将在这里结束：

    else{
        for(i=0; i<index-1; i++)
        p=p->next;
        x=p->data;
        p->prev->next=p->next;
         if(p->next)
         p->next->prev=p->prev;
        free(p);
     }   

else{
对于（i=0；不精确；
x=p->数据；
p->prev->next=p->next；
如果（p->next）
p->next->prev=p->prev；
自由基（p）；
}   

这又是：

    else{
        for(i=0; i<2-1; i++) // notice
        p=p->next;
        x=p->data;
        p->prev->next=p->next;
         if(p->next)
         p->next->prev=p->prev;
        free(p);
     }   

else{
对于（i=0；不精确；
x=p->数据；
p->prev->next=p->next；
如果（p->next）
p->next->prev=p->prev；
自由基（p）；
}   

或

else{
对于（i=0；不精确；
x=p->数据；
p->prev->next=p->next；//arghh…seg故障
如果（p->next）
p->next->prev=p->prev；
自由基（p）；
}   

因此，这与head元素和seg故障重叠，因为head没有prev元素

建议：使用零索引

顺便说一句：永远不要

        for(i=0; i<index-1; i++)
        p=p->next;

（i=0；不精确； 要么换成

        for(i=0; i<index-1; i++) p=p->next;

（i=0；不精确； 或者更好

        for(i=0; i<index-1; i++)
        {
            p=p->next;
        }

（i=0；不精确； }

        for(i=0; i<index-1; i++)
        {
            p=p->next;
        }