[已解决]为什么delete函数删不了最后一个元素

愿你

我的删除函数不能删除最后一个元素
那要怎么编写才可以？？
# include <stdio.h>
# include <stdlib.h>

typedef struct Dulnode{
        int data;
        struct Dulnode *prior;
        struct Dulnode *next;
}Dulnode,*Dulinklist;

void initlist(Dulinklist *L) //初始化双向链表
{
        (*L)=(Dulinklist)malloc(sizeof(Dulnode));
        if(!(*L))
                printf("无法正常分配空间，对不起哦！\n");
        else
        {
                (*L)->prior=(*L)->next=NULL;
                printf("初始化成功！");
        }
}


void creatlist(Dulinklist *L) //创建双向链表
{
        int n,i;
        Dulinklist r,p;//指向尾节点
        r=*L;
        printf("请问您想输入几个元素：");
        scanf("%d",&n);
        for(i=0;i<n;i++)
        {
                p=(Dulinklist)malloc(sizeof(Dulnode));
                if(!p)
                        printf("无法正常分配空间，对不起哦~\n");
                else
                {
                        printf("请输入第%d个元素",i+1);
                        scanf("%d",&p->data);
                        p->next=r->next;
                        p->prior=r;
                        r->next=p;
                        r=p;
                }
        }
}

void showlist(Dulinklist *L) //输出双向链表
{

        Dulinklist p;
        p=(*L)->next;
        if((*L)->next==NULL)
                printf("双向链表中没有元素，不可以输出哦~\n");
        else if((*L)->next!=NULL)
        {        printf("该双向链表中的元素为：");
                while(p!=NULL)
                {
                        printf("%d ",p->data);
                        p=p->next;
                }
        }
        else
                printf("您的线性表不存在哦，不可以显示元素呢~");
        printf("\n");
}

int lengthlist(Dulinklist L) //求表长
{
        Dulinklist p;
        int length=0;
        p=L->next;
        while(p!=NULL)
        {
                length++;
                p=p->next;
        }
        printf("您的表长为%d\n",length);
        return length;
}

void isemptylist(Dulinklist *L) //判断该双向链表是否为空
{
        if((*L)->next==NULL)
                printf("您的链表为空。\n");
        else
                printf("您的链表不为空\n");
}


void destroylist(Dulinklist *L)//销毁链表
{
        Dulinklist p,q;
        p=*L;
        while(p)
        {
                q=p->next;
                free(p);
                p=q;
        }
        printf("已经销毁线性表了哦~\n");
}

void clearlist(Dulinklist *L) //清空线性表
{
        Dulinklist p,q;
        p=(*L)->next;
        while(p!=NULL)
        {
                q=p->next;
                free(p);
                p=q;
        }
        (*L)->next=NULL;
        printf("已经清空双向链表了哦~\n");
}

void getelem(Dulinklist *L) //根据查询位置给出元素内容
{
        int i,j,e;
        Dulinklist p;
        printf("请问您想要查询哪一个位置的元素内容：");
        scanf("%d",&i);
        p=(*L)->next;
        j=0;
        while(p)
        {
                ++j;
                if(i==j)
                {
                        e=p->data;
                        printf("您查询的位置的元素内容为：%d\n",e);
                        break;
                }
                p=p->next;
        }
        if(i!=j||!p)
                printf("您的输入位置有误，无法查询。\n");
}

void locateelem(Dulinklist *L) //根据元素内容查询元素位置
{
        int e,j=0;
        Dulinklist p;
        p=(*L)->next;
        printf("请输入您想要查询的元素内容：");
        scanf("%d",&e);
        while(p)
        {
                j++;
                if(e==p->data)
                {
                        printf("您所要查询的元素内容位于%d号！\n",j);
                        break;
                }
                p=p->next;
        }
        if(!p)
                printf("无法查询到元素位置。\n");
}

void insertlist(Dulinklist *L) //在指定元素位置前插入某元素
{
        int i,e,j=0;
        Dulinklist p,s;
        p=(*L);
        printf("请问您想要在哪一号元素前插入什么内容：");
        scanf("%d,%d",&i,&e);
        while(p&&j<i-1)
        {
                p=p->next;       
                ++j;               
        }
        if(!p||j>i-1)
                printf("插入位置有误。\n");
        else
        {
                s=(Dulinklist)malloc(sizeof(Dulnode));
                if(!s)
                        printf("分配空间失败，无法进行插入~\n");
                else
                {
                        s->data=e;
                        s->prior=p;
                        s->next=p->next;
                        p->next->prior=s;
                        p->next=s;
                }
        }
}


void deletelist(Dulinklist *L)//删除某指定元素并用返回其值
{
        int i,j,e;
        Dulinklist p,q;
        p=(*L);
        j=0;
        printf("请问您想删除哪一号的元素内容：");
        scanf("%d",&i);
        while(p->next&&j<i-1)
        {       
                p=p->next;
                ++j;
        }
        if(!(p->next)||j>i-1)
                printf("删除位置有误。\n");
        else
        {
                q=p->next;
                e=q->data;
                p->next=q->next;
                q->next->prior=p;
                free(q);

        }

}


int main()
{
        Dulinklist L;
        initlist(&L);
        creatlist(&L);
        showlist(&L);
        isemptylist(&L);
        //clearlist(&L);
        //isemptylist(&L);
        //destroylist(&L);
        //showlist(&L);
        //getelem(&L);
        //locateelem(&L);
        lengthlist(L);
        insertlist(&L);
        showlist(&L);
        deletelist(&L);
        showlist(&L);
        lengthlist(L);
        return 0;
}@人造人

最佳答案

月排行榜 / 总排行榜

人造人

2018-4-3 09:02:01

1. 初始化成功！请问您想输入几个元素：4
   
2. 请输入第1个元素0
   
3. 请输入第2个元素1
   
4. 请输入第3个元素2
   
5. 请输入第4个元素3
   
6. 该双向链表中的元素为：0 1 2 3
   
7. 您的链表不为空
   
8. 您的表长为4
   
9. 请问您想要在哪一号元素前插入什么内容：1
   
10. 该双向链表中的元素为：-858993460 0 1 2 3
    
11. 请问您想删除哪一号的元素内容：3
    
12. 该双向链表中的元素为：-858993460 0 2 3
    
13. 您的表长为4
    
14. 请按任意键继续. . .

复制代码

你的问题是？？？

跳转到最佳答案楼层

人造人

1. 初始化成功！请问您想输入几个元素：4
   
2. 请输入第1个元素0
   
3. 请输入第2个元素1
   
4. 请输入第3个元素2
   
5. 请输入第4个元素3
   
6. 该双向链表中的元素为：0 1 2 3
   
7. 您的链表不为空
   
8. 您的表长为4
   
9. 请问您想要在哪一号元素前插入什么内容：1
   
10. 该双向链表中的元素为：-858993460 0 1 2 3
    
11. 请问您想删除哪一号的元素内容：3
    
12. 该双向链表中的元素为：-858993460 0 2 3
    
13. 您的表长为4
    
14. 请按任意键继续. . .

复制代码

你的问题是？？？

愿你

人造人 发表于 2018-4-3 09:02
你的问题是？？？

我现在没问题了这个删除函数。
我现在就还是搞不懂销毁的问题

愿你

人造人 发表于 2018-4-3 09:02
你的问题是？？？

我之前用单链表可以删除 现在我用双向链表又不可以删除了...
而且我只有最后一个元素不能删除，其他都可以正常删除

这是为什么？？？  是因为是双向链表吗？所以最后一个元素当执行q->next->prior=p语句会出问题吗？

我执行的结果是这样的：见图

1. # include <stdio.h>
   
2. # include <stdlib.h>
   
3. 
   
4. typedef struct Dulnode{
   
5.         int data;
   
6.         struct Dulnode *prior;
   
7.         struct Dulnode *next;
   
8. }Dulnode,*Dulinklist;
   
9. 
   
10. void initlist(Dulinklist *L) //初始化双向链表
    
11. {
    
12.         (*L)=(Dulinklist)malloc(sizeof(Dulnode));
    
13.         if(!(*L))
    
14.                 printf("无法正常分配空间，对不起哦！\n");
    
15.         else
    
16.         {
    
17.                 (*L)->prior=(*L)->next=NULL;
    
18.                 printf("初始化成功！");
    
19.         }
    
20. }
    
21. 
    
22. 
    
23. void creatlist(Dulinklist *L) //创建双向链表
    
24. {
    
25.         int n,i;
    
26.         Dulinklist r,p;//指向尾节点
    
27.         r=*L;
    
28.         printf("请问您想输入几个元素：");
    
29.         scanf("%d",&n);
    
30.         for(i=0;i<n;i++)
    
31.         {
    
32.                 p=(Dulinklist)malloc(sizeof(Dulnode));
    
33.                 if(!p)
    
34.                         printf("无法正常分配空间，对不起哦~\n");
    
35.                 else
    
36.                 {
    
37.                         printf("请输入第%d个元素",i+1);
    
38.                         scanf("%d",&p->data);
    
39.                         p->next=NULL;
    
40.                         p->prior=r;
    
41.                         r->next=p;
    
42.                         r=p;
    
43.                 }
    
44.         }
    
45. }
    
46. 
    
47. void showlist(Dulinklist *L) //输出双向链表
    
48. {
    
49. 
    
50.         Dulinklist p;
    
51.         p=(*L)->next;
    
52.         if((*L)->next==NULL)
    
53.                 printf("双向链表中没有元素，不可以输出哦~\n");
    
54.         else if((*L)->next!=NULL)
    
55.         {        printf("该双向链表中的元素为：");
    
56.                 while(p!=NULL)
    
57.                 {
    
58.                         printf("%d ",p->data);
    
59.                         p=p->next;
    
60.                 }
    
61.         }
    
62.         else
    
63.                 printf("您的线性表不存在哦，不可以显示元素呢~");
    
64.         printf("\n");
    
65. }
    
66. 
    
67. int lengthlist(Dulinklist *L) //求表长
    
68. {
    
69.         Dulinklist p;
    
70.         int length=0;
    
71.         p=(*L)->next;
    
72.         while(p!=NULL)
    
73.         {
    
74.                 length++;
    
75.                 p=p->next;
    
76.         }
    
77.         printf("您的表长为%d\n",length);
    
78.         return length;
    
79. }
    
80. 
    
81. void isemptylist(Dulinklist *L) //判断该双向链表是否为空
    
82. {
    
83.         if((*L)->next==NULL)
    
84.                 printf("您的链表为空。\n");
    
85.         else
    
86.                 printf("您的链表不为空\n");
    
87. }
    
88. 
    
89. 
    
90. void destroylist(Dulinklist *L)//销毁链表
    
91. {
    
92.         Dulinklist p,q;
    
93.         p=*L;
    
94.         while(p)
    
95.         {
    
96.                 q=p->next;
    
97.                 free(p);
    
98.                 p=q;
    
99.         }
    
100.         printf("已经销毁线性表了哦~\n");
     
101. }
     
102. 
     
103. void clearlist(Dulinklist *L) //清空线性表
     
104. {
     
105.         Dulinklist p,q;
     
106.         p=(*L)->next;
     
107.         while(p!=NULL)
     
108.         {
     
109.                 q=p->next;
     
110.                 free(p);
     
111.                 p=q;
     
112.         }
     
113.         (*L)->next=NULL;
     
114.         printf("已经清空双向链表了哦~\n");
     
115. }
     
116. 
     
117. /*void getelem(Dulinklist *L) //根据查询位置给出元素内容
     
118. {
     
119.         int i,j,e;
     
120.         Dulinklist p;
     
121.         printf("请问您想要查询哪一个位置的元素内容：");
     
122.         scanf("%d",&i);
     
123.         p=(*L)->next;
     
124.         j=0;
     
125.         while(p)
     
126.         {
     
127.                 ++j;
     
128.                 if(i==j)
     
129.                 {
     
130.                         e=p->data;
     
131.                         printf("您查询的位置的元素内容为：%d\n",e);
     
132.                         break;
     
133.                 }
     
134.                 p=p->next;
     
135.         }
     
136.         if(i!=j||!p)
     
137.                 printf("您的输入位置有误，无法查询。\n");
     
138. }*/
     
139. 
     
140. void getelem(Dulinklist *L)
     
141. {
     
142.         int i,j,e;
     
143.         Dulinklist p;
     
144.         printf("请问您想要查询哪一个位置的元素内容：");
     
145.         scanf("%d",&i);
     
146.         p=(*L),j=0;
     
147.         while(p&&j<i)
     
148.         {
     
149.                 p=p->next;
     
150.                 j++;
     
151.         }
     
152.         if(!p||j>i)
     
153.                 printf("查询位置有误，无法查询\n");
     
154.         else
     
155.         {
     
156.                 e=p->data;
     
157.                 printf("您查询的位置的元素是：%d\n",e);
     
158.         }
     
159. }
     
160. 
     
161. 
     
162. 
     
163. void locateelem(Dulinklist *L) //根据元素内容查询元素位置
     
164. {
     
165.         int e,j=0;
     
166.         Dulinklist p;
     
167.         p=(*L)->next;
     
168.         printf("请输入您想要查询的元素内容：");
     
169.         scanf("%d",&e);
     
170.         while(p)
     
171.         {
     
172.                 j++;
     
173.                 if(e==p->data)
     
174.                 {
     
175.                         printf("您所要查询的元素内容位于%d号！\n",j);
     
176.                         break;
     
177.                 }
     
178.                 p=p->next;
     
179.         }
     
180.         if(!p)
     
181.                 printf("无法查询到元素位置。\n");
     
182. }
     
183. 
     
184. void insertlist(Dulinklist *L) //在指定元素位置前插入某元素
     
185. {
     
186.         int i,e,j=0;
     
187.         Dulinklist p,s;
     
188.         p=(*L);
     
189.         printf("请问您想要在哪一号元素前插入什么内容：");
     
190.         scanf("%d,%d",&i,&e);
     
191.         while(p&&j<i-1)
     
192.         {
     
193.                 p=p->next;       
     
194.                 ++j;               
     
195.         }
     
196.         if(!p||j>i-1)
     
197.                 printf("插入位置有误。\n");
     
198.         else
     
199.         {
     
200.                 s=(Dulinklist)malloc(sizeof(Dulnode));
     
201.                 if(!s)
     
202.                         printf("分配空间失败，无法进行插入~\n");
     
203.                 else
     
204.                 {
     
205.                         s->data=e;
     
206.                         s->prior=p;
     
207.                         s->next=p->next;
     
208.                         p->next->prior=s;
     
209.                         p->next=s;
     
210.                 }
     
211.         }
     
212. }
     
213. 
     
214. 
     
215. void deletelist(Dulinklist *L)//删除某指定元素并用返回其值
     
216. {
     
217.         int i,j,e,len;
     
218.         Dulinklist p,q;
     
219.         p=(*L);
     
220.         j=0;
     
221.         printf("请问您想删除哪一号的元素内容：");
     
222.         scanf("%d",&i);
     
223.         while(p&&j<i-1)
     
224.         {       
     
225.                 p=p->next;
     
226.                 ++j;
     
227.         }
     
228.         if(!p||j>i-1)
     
229.                 printf("删除位置有误。\n");
     
230. 
     
231.         else
     
232.         {
     
233.                 q=p->next;
     
234.                 e=q->data;
     
235.                
     
236.                 p->next=q->next;
     
237.                 q->next->prior=p;
     
238.                 free(q);
     
239.         }
     
240. 
     
241. 
     
242. }
     
243. 
     
244. 
     
245. int main()
     
246. {
     
247.         Dulinklist L;
     
248.         initlist(&L);
     
249.         creatlist(&L);
     
250.         showlist(&L);
     
251.         //isemptylist(&L);
     
252.         //clearlist(&L);
     
253.         //isemptylist(&L);
     
254.         //destroylist(&L);
     
255.         //showlist(&L);
     
256.         //getelem(&L);
     
257.         //locateelem(&L);
     
258.         lengthlist(&L);
     
259.         //insertlist(&L);
     
260.         //showlist(&L);
     
261.         deletelist(&L);
     
262.         showlist(&L);
     
263.         lengthlist(&L);
     
264.         return 0;
     
265. }

复制代码

人造人

愿你 发表于 2018-4-3 21:12
我之前用单链表可以删除 现在我用双向链表又不可以删除了...
而且我只有最后一个元素不能删除，其他都可 ...

1. # include <stdio.h>
   
2. # include <stdlib.h>
   
3. 
   
4. typedef struct Dulnode {
   
5.         int data;
   
6.         struct Dulnode *prior;
   
7.         struct Dulnode *next;
   
8. }Dulnode, *Dulinklist;
   
9. 
   
10. void initlist(Dulinklist *L) //初始化双向链表
    
11. {
    
12.         (*L) = (Dulinklist)malloc(sizeof(Dulnode));
    
13.         if(!(*L))
    
14.                 printf("无法正常分配空间，对不起哦！\n");
    
15.         else
    
16.         {
    
17.                 (*L)->prior = (*L)->next = NULL;
    
18.                 printf("初始化成功！");
    
19. 
    
20. 
    
21.                 (*L)->data = 1234;        // debug
    
22.         }
    
23. }
    
24. 
    
25. 
    
26. void creatlist(Dulinklist *L) //创建双向链表
    
27. {
    
28.         int n, i;
    
29.         Dulinklist r, p;//指向尾节点
    
30.         r = *L;
    
31.         printf("请问您想输入几个元素：");
    
32.         scanf("%d", &n);
    
33.         for(i = 0; i<n; i++)
    
34.         {
    
35.                 p = (Dulinklist)malloc(sizeof(Dulnode));
    
36.                 if(!p)
    
37.                         printf("无法正常分配空间，对不起哦~\n");
    
38.                 else
    
39.                 {
    
40.                         printf("请输入第%d个元素", i + 1);
    
41.                         scanf("%d", &p->data);
    
42.                         p->next = NULL;
    
43.                         p->prior = r;
    
44.                         r->next = p;
    
45.                         r = p;
    
46.                 }
    
47.         }
    
48. }
    
49. 
    
50. void showlist(Dulinklist *L) //输出双向链表
    
51. {
    
52. 
    
53.         Dulinklist p;
    
54.         p = (*L)->next;
    
55.         if((*L)->next == NULL)
    
56.                 printf("双向链表中没有元素，不可以输出哦~\n");
    
57.         else if((*L)->next != NULL)
    
58.         {
    
59.                 printf("该双向链表中的元素为：");
    
60.                 while(p != NULL)
    
61.                 {
    
62.                         printf("%d ", p->data);
    
63.                         p = p->next;
    
64.                 }
    
65.         }
    
66.         else
    
67.                 printf("您的线性表不存在哦，不可以显示元素呢~");
    
68.         printf("\n");
    
69. }
    
70. 
    
71. int lengthlist(Dulinklist *L) //求表长
    
72. {
    
73.         Dulinklist p;
    
74.         int length = 0;
    
75.         p = (*L)->next;
    
76.         while(p != NULL)
    
77.         {
    
78.                 length++;
    
79.                 p = p->next;
    
80.         }
    
81.         printf("您的表长为%d\n", length);
    
82.         return length;
    
83. }
    
84. 
    
85. void isemptylist(Dulinklist *L) //判断该双向链表是否为空
    
86. {
    
87.         if((*L)->next == NULL)
    
88.                 printf("您的链表为空。\n");
    
89.         else
    
90.                 printf("您的链表不为空\n");
    
91. }
    
92. 
    
93. 
    
94. void destroylist(Dulinklist *L)//销毁链表
    
95. {
    
96.         Dulinklist p, q;
    
97.         p = *L;
    
98.         while(p)
    
99.         {
    
100.                 q = p->next;
     
101.                 free(p);
     
102.                 p = q;
     
103.         }
     
104.         printf("已经销毁线性表了哦~\n");
     
105. }
     
106. 
     
107. void clearlist(Dulinklist *L) //清空线性表
     
108. {
     
109.         Dulinklist p, q;
     
110.         p = (*L)->next;
     
111.         while(p != NULL)
     
112.         {
     
113.                 q = p->next;
     
114.                 free(p);
     
115.                 p = q;
     
116.         }
     
117.         (*L)->next = NULL;
     
118.         printf("已经清空双向链表了哦~\n");
     
119. }
     
120. 
     
121. /*void getelem(Dulinklist *L) //根据查询位置给出元素内容
     
122. {
     
123. int i,j,e;
     
124. Dulinklist p;
     
125. printf("请问您想要查询哪一个位置的元素内容：");
     
126. scanf("%d",&i);
     
127. p=(*L)->next;
     
128. j=0;
     
129. while(p)
     
130. {
     
131. ++j;
     
132. if(i==j)
     
133. {
     
134. e=p->data;
     
135. printf("您查询的位置的元素内容为：%d\n",e);
     
136. break;
     
137. }
     
138. p=p->next;
     
139. }
     
140. if(i!=j||!p)
     
141. printf("您的输入位置有误，无法查询。\n");
     
142. }*/
     
143. 
     
144. void getelem(Dulinklist *L)
     
145. {
     
146.         int i, j, e;
     
147.         Dulinklist p;
     
148.         printf("请问您想要查询哪一个位置的元素内容：");
     
149.         scanf("%d", &i);
     
150.         p = (*L), j = 0;
     
151.         while(p&&j<i)
     
152.         {
     
153.                 p = p->next;
     
154.                 j++;
     
155.         }
     
156.         if(!p || j>i)
     
157.                 printf("查询位置有误，无法查询\n");
     
158.         else
     
159.         {
     
160.                 e = p->data;
     
161.                 printf("您查询的位置的元素是：%d\n", e);
     
162.         }
     
163. }
     
164. 
     
165. 
     
166. 
     
167. void locateelem(Dulinklist *L) //根据元素内容查询元素位置
     
168. {
     
169.         int e, j = 0;
     
170.         Dulinklist p;
     
171.         p = (*L)->next;
     
172.         printf("请输入您想要查询的元素内容：");
     
173.         scanf("%d", &e);
     
174.         while(p)
     
175.         {
     
176.                 j++;
     
177.                 if(e == p->data)
     
178.                 {
     
179.                         printf("您所要查询的元素内容位于%d号！\n", j);
     
180.                         break;
     
181.                 }
     
182.                 p = p->next;
     
183.         }
     
184.         if(!p)
     
185.                 printf("无法查询到元素位置。\n");
     
186. }
     
187. 
     
188. void insertlist(Dulinklist *L) //在指定元素位置前插入某元素
     
189. {
     
190.         int i, e, j = 0;
     
191.         Dulinklist p, s;
     
192.         p = (*L);
     
193.         printf("请问您想要在哪一号元素前插入什么内容：");
     
194.         scanf("%d,%d", &i, &e);
     
195.         while(p&&j<i - 1)
     
196.         {
     
197.                 p = p->next;
     
198.                 ++j;
     
199.         }
     
200.         if(!p || j>i - 1)
     
201.                 printf("插入位置有误。\n");
     
202.         else
     
203.         {
     
204.                 s = (Dulinklist)malloc(sizeof(Dulnode));
     
205.                 if(!s)
     
206.                         printf("分配空间失败，无法进行插入~\n");
     
207.                 else
     
208.                 {
     
209.                         s->data = e;
     
210.                         s->prior = p;
     
211.                         s->next = p->next;
     
212.                         p->next->prior = s;
     
213.                         p->next = s;
     
214.                 }
     
215.         }
     
216. }
     
217. 
     
218. 
     
219. void deletelist(Dulinklist *L)//删除某指定元素并用返回其值
     
220. {
     
221.         int i, j, e;
     
222.         Dulinklist p, q;
     
223.         p = (*L);
     
224.         j = 0;
     
225.         printf("请问您想删除哪一号的元素内容：");
     
226.         scanf("%d", &i);
     
227.         while(p&&j<i - 1)
     
228.         {
     
229.                 p = p->next;
     
230.                 ++j;
     
231.         }
     
232.         if(!p || j>i - 1)
     
233.                 printf("删除位置有误。\n");
     
234. 
     
235.         else
     
236.         {
     
237.                 q = p->next;
     
238.                 e = q->data;
     
239. 
     
240.                 p->next = q->next;
     
241.                 if(q->next != NULL)
     
242.                         q->next->prior = p;
     
243.                 free(q);
     
244.         }
     
245. 
     
246. 
     
247. }
     
248. 
     
249. 
     
250. int main()
     
251. {
     
252.         Dulinklist L;
     
253.         initlist(&L);
     
254.         creatlist(&L);
     
255.         showlist(&L);
     
256.         //isemptylist(&L);
     
257.         //clearlist(&L);
     
258.         //isemptylist(&L);
     
259.         //destroylist(&L);
     
260.         //showlist(&L);
     
261.         //getelem(&L);
     
262.         //locateelem(&L);
     
263.         lengthlist(&L);
     
264.         //insertlist(&L);
     
265.         //showlist(&L);
     
266.         deletelist(&L);
     
267.         showlist(&L);
     
268.         lengthlist(&L);
     
269.         return 0;
     
270. }
     

复制代码

愿你

人造人 发表于 2018-4-3 21:56

我之前用的是这种，但是没出来
不过你就添加了一句!!!太棒了吧也!!!!

1. void deletelist(Dulinklist *L)//删除某指定元素并用返回其值
   
2. {
   
3.         int i,j,e,len;
   
4.         Dulinklist p,q;
   
5.         p=(*L);
   
6.         j=0;
   
7.         len=lengthlist(&L);
   
8.         printf("请问您想删除哪一号的元素内容：");
   
9.         scanf("%d",&i);
   
10.         while(p&&j<i-1)
    
11.         {       
    
12.                 p=p->next;
    
13.                 ++j;
    
14.         }
    
15.         if(!p||j>i-1)
    
16.                 printf("删除位置有误。\n");
    
17.         else if(i==len)
    
18.         {
    
19.                 q=p->next;
    
20.                 e=q->data;
    
21.                
    
22.                 p->next=q->next;
    
23.                 free(q);
    
24. 
    
25.         }
    
26.         else
    
27.         {
    
28.                 q=p->next;
    
29.                 e=q->data;
    
30.                
    
31.                 p->next=q->next;
    
32.                 q->next->prior=p;
    
33.                 free(q);
    
34.         }

复制代码

人造人

愿你 发表于 2018-4-3 22:02
我之前用的是这种，但是没出来
不过你就添加了一句!!!太棒了吧也!!!!

意思是问题解决了?

人造人

愿你 发表于 2018-4-3 22:02
我之前用的是这种，但是没出来
不过你就添加了一句!!!太棒了吧也!!!!

这个结果是调试出来的，要学会调试
^_^

愿你

人造人 发表于 2018-4-3 22:05
意思是问题解决了?

对呀你解决了我的问题~

愿你

人造人 发表于 2018-4-3 22:05
这个结果是调试出来的，要学会调试
^_^

我还是没学会调试
我中午找找资源
我之前找过了 都没看到合适的

愿你

whx2008 发表于 2018-4-4 23:32
太难啊了！想不到啊！！！

加油

人造人

愿你 发表于 2018-4-16 09:38
我还是没学会调试
我中午找找资源
我之前找过了 都没看到合适的

^_^