程序目的如图：

程序代码如下：

#include  <stdio.h>
#include  <stdlib.h>
#define  LEN  sizeof(NodeList)

struct NodeList {
   int  number;
   NodeList  *next;
};

void OutputList(NodeList *);
NodeList *CreateList(int a[], int );
NodeList *DeleteList(NodeList *);

int  main()
{
    int array[100] ;
    int length = 0;
    NodeList  *head;
    char ch;

    printf("Please input a number sequence:\n");
    do
    {
        scanf("%d", &array[length++]);
            ch = getchar();
    }while (ch != '\n');
    head = CreateList(array, length);
    printf("The original list is:\n");
    OutputList(head);
    printf("\n");
    printf("The list after delete is:\n");
    DeleteList(head);
    OutputList(head);
    printf("\n");
    return 0;
}

NodeList *CreateList(int a[], int length)
{
    NodeList  *head, *p1, *p2;
    int i = 0;

    head = p1 = p2 = (NodeList *)malloc(LEN);
    do{
        p2 -> number = a[i++];   
        p1 = (NodeList *)malloc(LEN);
        p2 -> next = p1;
        p2 = p1;
    }while (i < length);
    p2 -> next = NULL;
    return head;
}

void OutputList(NodeList *head)
{
     NodeList  *p;
     p = head;
     while (p -> next != NULL)
     {
         printf("%d ", p -> number);
         p = p -> next;
     }
}

NodeList *DeleteList(NodeList *head)
{
     NodeList  *p1, *p2, *p3;

     p3 = p2 = head;
     p1 = p3 -> next;
    while (p3 -> next  != NULL)
    {
       while (p1 != NULL)
       {        
          if (p1 -> number == p3 -> number)
          {
            p1 = p1 -> next;
            p2 -> next = p1;
          }
          else
          {
              p2 = p1;
              p1 = p1 -> next;
          }
       }
       p3 = p2 = p3 -> next;
       p1 = p3 -> next;
    }
    return head;
}

我现在的问题是，CreateList()函数使用malloc（）申请了内存，为了不使内存泄露必须手动free();那么是在主函数中释放还是在子函数中释放？由于是一个链表，那么怎么释放每一个结点内存？我看到很多程序就直接写个
    free(p)完事，这能达到目的吗？比如我上面的程序，怎么释放？

你不是写了个DeleteList函数么，在这里释放不就挺好。这个函数没必然返回值。另外你好像也在学C++，写一个链表类，在析构函数里释放内存。

自动释放，https://hi.bccn.net/space-383031-do-blog-id-34432.html
第四节，第二个例子代码。

那里释放好像都无所谓吧？，别释放了在当返回值..使用就好了。直接一个free(p)可能不行，一个一个节点慢慢释放吧 ，释放就从头节点开始释放（假设a指向头节点），让一个指针（假设B）指向头节点的下一个节点，释放完在让a指向b，b在指向b指向的下一个节点，然后循环判断a是不是尾节点 在相应操作就行啦   我没实践过啊，可以参考一下

if (p1 -> number == p3 -> number)
          {
            p2 -> next = p1 -> next;        
            free(p1);
            p1 = p2 -> next;
          }
这样释放被删除的结点内存，未被删除的结点内存就要用list_destroy()函数来释放了吧？

你的程序是去重吧   直接开哈希表效率最高  对于链表释放是要用递归

void del(Node *root)
{

    if(root->next)
        del(root->next);
    delete root;
}

里面的函数套了好几层，有点晕。
#include "list.h"
#include "list_impl.h" 这个头文件很少看到啊，库里没有怎么办。
assert(data_size > 0);有什么用，防御编程吗？
NEWC又是什么东东？
destruct_func（）这个函数整篇都没提及，那里来的？

哈哈 ，这个好。

改进了下，大家看有没有错误的地方：

#include  <stdio.h>
#include  <stdlib.h>
#define  LEN  sizeof(NodeList)

struct NodeList {
   int  number;
   NodeList  *next;
};

void OutputList(NodeList *);
NodeList *CreateList(int a[], int );
NodeList *DeleteList(NodeList *);
void  FreeList(NodeList *head);

int  main()
{
    int array[100] ;
    int length = 0;
    NodeList  *head;
    char ch;

    printf("Please input a number sequence:\n");
    do
    {
        scanf("%d", &array[length++]);
            ch = getchar();
    }while (ch != '\n');
    head = CreateList(array, length);
    printf("The original list is:\n");
    OutputList(head);
    printf("\n");
    printf("The list after delete is:\n");
    DeleteList(head);
    OutputList(head);
    FreeList(head);
    printf("\n");
    return 0;
}

NodeList *CreateList(int a[], int length)
{
    NodeList  *head, *p1, *p2;
    int i = 0;

    head = p1 = p2 = (NodeList *)malloc(LEN);
    do{
        p2 -> number = a[i++];   
        p1 = (NodeList *)malloc(LEN);
        p2 -> next = p1;
        p2 = p1;
    }while (i < length);
    p2 -> next = NULL;
    return head;
}

void OutputList(NodeList *head)
{
     NodeList  *p;
     p = head;
     while (p -> next != NULL)
     {
         printf("%d ", p -> number);
         p = p -> next;
     }
}

NodeList *DeleteList(NodeList *head)
{
     NodeList  *p1, *p2, *p3;

     p3 = p2 = head;
     p1 = p3 -> next;
    while (p3 -> next  != NULL)
    {
       while (p1 != NULL)
       {        
          if (p1 -> number == p3 -> number)
          {
            p2 -> next = p1 -> next;       
            free(p1);                         // 循环释放删除的结点内存
            p1 = p2 -> next;
          }
          else
          {
              p2 = p1;
              p1 = p1 -> next;
          }
       }
       p3 = p2 = p3 -> next;
       p1 = p3 -> next;
    }
    return head;
}

void  FreeList(NodeList *head)             //  递归释放结点内存，参考老杨的方法
{
    if (head -> next)
    {
        FreeList(head -> next);
    }
    free(head);
}

[ 本帖最后由 有容就大 于 2012-2-6 15:43 编辑 ]

里面的函数套了好几层，有点晕。
不就是C代码么？哪里让你头晕了？写法多种多样罢了。

这两个头都是自己写的。。。不存在库里面有没有。
所有的代码都在下载包里。

assert(data_size > 0);有什么用？你编程从来不用这个么？

NEWC 是一个宏，在《C和C指针》一书里有提到。

destruct_func（）这个函数，自己写的。就是用来释放如果节点数据也是动态分配的情况。
它的由来。。。第五点中有述。类似于C++的析构函数。

[ 本帖最后由 hellovfp 于 2012-2-6 15:47 编辑 ]