求大神看看我这个程序那里错了

一介白书生

已知线性表的元素按递增顺序排列，并以带头结点的单链表作为存储结构。试编写一个删除表中所有值大于min并且小于max的元素的算法。
函数原型：void del(struct node *head,int min,int max);
单链表结点结构为：
struct node
{   int data;
    struct node *next;
};

Input

第一行 包含一个n，代表链表中所含元素的个数。
第二行 包含n个数，代表链表中的元素。
第三行 max 与min ( max > min )。
注意：测试数据包含多组
Output

要求删除[min,max]区间内的所有元素，若不存在，则不执行任何操作。
Sample Input
5
1 2 3 4 5
2 3
6
12 5 6 4 6 9
2 4
Sample Output
1 4 5
12 5 6 6 9
#include <stdio.h>
#include <stdlib.h>
typedef struct node
{
    int data;
    struct node *next;
}Node;
Node *CreatNode()
{
    Node *p = (Node*)malloc(sizeof(Node));
    p->next = NULL;
    return p;
}
void InsertNodeElem(Node *head,int elem)
{
    Node *pCur = head,*pNew = (Node*)malloc(sizeof(Node));
    pNew->data = elem;

    pNew->next = pCur->next;
    pCur->next = pNew;
}
void del(Node *head,int min,int max)
{
    Node *pCur = head,*pTemp,*pCurrent,*pT;
       while(pCur!=NULL)
       {
           pT = pCur->next;pTemp = pT;
           if((pT==NULL) && (pCur->data >= min) && (pCur->data<=max))
           {
               free(pCur);
               break;
           }

        if(pTemp->data >= min && pTemp->data <= max)
        {
            pCurrent = pTemp;
            if(pCurrent->next==NULL)
            {
                pCur->next = NULL;
                free(pCurrent);
                break;
            }
            pCur->next = pCurrent->next;
            free(pTemp);
        }
        else
        {
            pCur = pCur->next;
        }
       }



}
void PrintNode(Node *head)
{
    Node *pCur = head->next;
    while(pCur!=NULL)
    {
        printf("%d ",pCur->data);
        pCur = pCur ->next;
    }
}
int NodeLength(Node *head)
{
    int len = 0;
    Node *pCur = head->next;
    while(pCur!=NULL)
    {
        len++;
        pCur = pCur ->next;
    }
    return len;
}
void main()
{
    Node *head = CreatNode();
    int len = 0,i = 0,elem = 0,max = 0,min = 0;
    scanf("%d",&len);
    for(i=0;i<len;i++)
    {
       scanf("%d",&elem);
       InsertNodeElem(head,elem);
    }
    scanf("%d %d",&min,&max);
    del(head,min,max);
    PrintNode(head);
}
应该是删除函数有错，

小新110

确实是del函数有点问题

1. 
   
2. void del(Node *head,int min,int max)
   
3. {
   
4.         Node *pCur = head,*pTemp,*pCurrent,*pT;
   
5.         while(pCur!=NULL)
   
6.         {
   
7.                 pT = pCur->next;pTemp = pT;
   
8.                 if(pT==NULL)  
   
9.                 {
   
10.                         if ((pCur->data >= min) && (pCur->data<=max))
    
11.                         {
    
12.                                 free(pCur);
    
13.                         }
    
14.                         break;
    
15.                 }
    
16. 
    
17.                 if(pTemp->data >= min && pTemp->data <= max)
    
18.                 {
    
19.                         pCurrent = pTemp;
    
20.                         if(pCurrent->next==NULL)
    
21.                         {
    
22.                                 pCur->next = NULL;
    
23.                                 free(pCurrent);
    
24.                                 break;
    
25.                         }
    
26.                         pCur->next = pCurrent->next;
    
27.                         free(pTemp);
    
28.                 }
    
29.                 else
    
30.                 {
    
31.                         pCur = pCur->next;
    
32.                 }
    
33.         }
    
34. }

复制代码

熊文杰

这个题目首先第一个要抓住的要点是
按递增顺序排列
既然是按照递增的顺序排列，那就简单了。因为顺序是排好的，
1.只要找到第一个比min大的结点，让pHead头指针指向那个结点，此结点之前的全部free掉。
2.找到最后一个比max小的结点，这个结点就是最后一个尾结点。这个结点之后的全部free掉。

充分利用递增顺序表这个规则，可以简化程序
在你的代码基础上 我加了几个函数如下。所有的代码如下通过visual stdio 2005编译运行测试成功

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

复制代码

1. typedef struct node
   
2. {
   
3.         int data;
   
4.         struct node *next;
   
5. }Node;
   
6. Node *CreatNode()
   
7. {
   
8.         Node *p = (Node*)malloc(sizeof(Node));
   
9.         p->next = NULL;
   
10.         return p;
    
11. }
    
12. void InsertNodeElem(Node *head,int elem)
    
13. {
    
14.         Node *pCur = head;
    
15.         Node* pNew = (Node*)malloc(sizeof(Node));
    
16.         pNew->data = elem;
    
17. 
    
18.         pNew->next = pCur->next;
    
19.         pCur->next = pNew;
    
20. }
    
21. 
    
22. //清除pHead开始的全部结点
    
23. void clear(Node *pHead)
    
24. {
    
25.         Node *pNode = pHead;
    
26.         Node *pFront = NULL;//指向pNode前面一个结点
    
27.         while (pNode)
    
28.         {
    
29.                 pFront = pNode;
    
30.                 pNode = pNode->next;
    
31.                 free(pFront);
    
32.                 pFront = NULL;
    
33.         }
    
34.         pHead = NULL;
    
35. }
    
36. 
    
37. void delMin(Node *head,int min)
    
38. {
    
39.         Node *pNode = head;
    
40.         while (head)
    
41.         {
    
42.                 pNode = head->next;
    
43.                 if (pNode)
    
44.                 {
    
45.                         if (pNode->data > min)
    
46.                         {
    
47.                                 head->next = pNode;
    
48.                                 break;
    
49.                         }
    
50.                         else
    
51.                         {
    
52.                                 head->next = pNode->next;
    
53.                                 free(pNode);
    
54.                                 pNode = NULL;
    
55.                         }
    
56.                 }
    
57.         }
    
58. }
    
59. 
    
60. void delMax(Node *head,int max)
    
61. {
    
62.         Node *pNode = head;
    
63.         Node *pEndNode = head->next;   //指向结尾结点
    
64.         while (pEndNode)
    
65.         {
    
66.                 pNode = pNode->next;
    
67. 
    
68.                 if (pNode)
    
69.                 {
    
70.                         if (pNode->data < max)
    
71.                         {
    
72.                                 pEndNode = pNode;
    
73.                                 continue;
    
74.                         }
    
75.                         else
    
76.                         {
    
77.                                 clear(pNode);
    
78.                                 pEndNode->next = NULL;
    
79.                                 break;
    
80.                         }
    
81.                 }
    
82.         }
    
83. }
    
84. void deleteObj(Node *head,int min,int max)
    
85. {
    
86.         delMin(head,min);
    
87.         delMax(head,max);
    
88. }
    
89. 
    
90. void del(Node *head,int min,int max)
    
91. {
    
92.         Node *pCur = head;
    
93.         Node *pTemp = NULL;
    
94.         Node *pCurrent = NULL;
    
95.         Node *pT = NULL;
    
96. 
    
97.         while(pCur!=NULL)
    
98.         {
    
99.                 pT = pCur->next;
    
100.                 pTemp = pT;
     
101.                 if((pT==NULL) && (pCur->data >= min) && (pCur->data<=max))
     
102.                 {
     
103.                         free(pCur);
     
104.                         break;
     
105.                 }
     
106. 
     
107.                 if(pTemp->data >= min && pTemp->data <= max)
     
108.                 {
     
109.                         pCurrent = pTemp;
     
110.                         if(pCurrent->next==NULL)
     
111.                         {
     
112.                                 pCur->next = NULL;
     
113.                                 free(pCurrent);
     
114.                                 break;
     
115.                         }
     
116.                         pCur->next = pCurrent->next;
     
117.                         free(pTemp);
     
118.                 }
     
119.                 else
     
120.                 {
     
121.                         pCur = pCur->next;
     
122.                 }
     
123.         }
     
124. 
     
125. 
     
126. 
     
127. }
     
128. void PrintNode(Node *head)
     
129. {
     
130.         Node *pCur = head->next;
     
131.         while(pCur)
     
132.         {
     
133.                 printf("%d ",pCur->data);
     
134.                 pCur = pCur ->next;
     
135.         }
     
136. }
     
137. int NodeLength(Node *head)
     
138. {
     
139.         int len = 0;
     
140.         Node *pCur = head->next;
     
141.         while(pCur!=NULL)
     
142.         {
     
143.                 len++;
     
144.                 pCur = pCur ->next;
     
145.         }
     
146.         return len;
     
147. }
     
148. 
     
149. int _tmain(int argc, _TCHAR* argv[])
     
150. {
     
151.         Node *head = CreatNode();
     
152.         int len = 0,i = 0,elem = 0,max = 0,min = 0;
     
153.         scanf("%d",&len);
     
154.         for(i=0;i<len;i++)
     
155.         {
     
156.                 scanf("%d",&elem);
     
157.                 InsertNodeElem(head,elem);
     
158.         }
     
159.         scanf("%d %d",&min,&max);
     
160. 
     
161.         deleteObj(head,min,max);
     
162.         PrintNode(head);
     
163.         return 0;
     
164. }

复制代码

一介白书生

小新110 发表于 2013-5-15 21:54

                               
登录/注册后可看大图

确实是del函数有点问题

谢谢，我已经知道怎么写了

y290176346

我是来领 鱼币的

东河

看看

鱼C工作室.YCGZS

好像有些标点什么的是检测不出的