单向链表

/*2010-09-07*/
/*单向链表*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct node//每一个节点就是一个结构体类型的数据
{
    int x;
    struct node* next;
}NODE;
//typedef NODE struct node//不能这样宏定义!

//typedef struct node NODE;//这样定义才是正确的！
/*********************************************************
 *函数名称：init_list
 *函数功能：初始化单向链表
  函数参数：传入链表头指针的指针(因为要修改的是指针本身)
 *返回值：  空
 * *******************************************************/
void init_list(NODE** pHead)
{
    if(NULL!=*pHead)
    {
        printf("in init_list,*pHead is not NULL,you had better not to do anything on it!/n");
    }
    *pHead=(NODE*)malloc(sizeof(NODE));
    if(NULL==*pHead)
    {
        printf("in init_list,*pHead is NULL/n");
        exit(-1);
    }
    memset(*pHead,0,sizeof(NODE));
    printf("init_list success! well done!/n");
}
/***************************************************************
 *函数名称：add_node
 *函数功能：在链表的尾部添加一个节点
 *函数参数：传入链表的头指针，pHead用于指向添加节点的位置，node用于数据
  返回值：  空
 * **************************************************************/
void add_node(NODE* pHead,NODE node)
{
    if(NULL==pHead)//判断链表是否已产生
    {
        printf("int add_node,pHead is NULL/n");
        exit(-1);
    }
    while(pHead->next!=NULL)//调试正确前写成了while(pHead!=NULL)
    {                      //若当前节点的next不为NULL，也就是还没到最后一个节点
        pHead=pHead->next;//这样找到链表的最后一个节点
    }                    //while完后pHead指向最后一个节点
    pHead->next=(NODE*)malloc(sizeof(NODE));//调试正确前写成了pHead=(NODE*)malloc(sizeof(NODE));
                                           //在最后一个节点的后面开辟空间
    if(NULL==pHead->next)//判断开辟空间是否成功
    {
        printf("in add_node,malloc error!/n");
        exit(-1);
    }
   
    pHead=pHead->next;//调试正确前缺少这一句//第一个节点最好不要存数据
    pHead->x=node.x;//把值存入到新开辟的空间中
    pHead->next=NULL;
    printf("add_node success! well done!/n");

}

/*******************************************************************
 *函数名称：find_node
 *函数功能：查找符合条件的一个节点
 *函数参数：传入链表头指针
 *返回值：  空
 * ******************************************************************/
void find_node(NODE* pHead,int n)
{
    if(pHead==NULL)
    {
        printf("wrong6/n");
        exit(-1);
    }
    if(pHead->next==NULL)
    {
        printf("sorry! the list is empty!/n");
        exit(-1);
    }
    while(pHead->next!=NULL)
    {
        pHead=pHead->next;
        if(pHead->x==n)
        {
            printf("you have found the node!");
            printf("what you find is %d/n",pHead->x);
            return ;
        }
    }
    printf("sorry! cannot find the node!/n");
}
/*****************************************************************
 *函数名称：display_list
 *函数功能：显示链表的数据
 *函数参数：传入链表的头指针
 *返回值：  空
 * ****************************************************************/
void display_list(NODE* pHead)
{
    if(NULL==pHead)//判断，以免出现段错误
    {
        printf("in display_list,pHead is NULL/n");
        exit(-1);
    }
    if(NULL==pHead->next)
    {
        printf("in display_list,the link is empty!/n");
        exit(-1);
    }
    while(pHead->next!=NULL)
    {
        printf("%d/n",pHead->next->x);//头节点没存数据
        pHead=pHead->next;
    }
    printf("display_list success! well done!/n");
}

/*****************************************************************
 *函数名称：del_node
 *函数功能：删除符合条件的一个节点
 *函数参数：传入链表头指针
 *返回值：  空
 * ****************************************************************/
void del_node(NODE* pHead,int n)//need more!
{
    if(pHead==NULL)
    {
        printf("wrong7/n");
        exit(-1);
    }
    if(pHead->next==NULL)
    {
        printf("sorry!the list is empty!/n");
        exit(-1);
    }

    NODE* pDel=pHead->next;
    while(pHead->next!=NULL)
    {
       
        if(pHead->next->x==n)
        {
            pHead->next=pDel->next;
            free(pDel);
            printf("del_node success!/n");
            return ;
        }
        pDel=pDel->next;
        pHead=pHead->next;
    }
    printf("sorry! del_node fail!/n");
}
/*******************************************************************
 *函数名称：dele_list
 *函数功能：删除链表
 *函数参数：传入链表头指针的指针
 *返回值：  空
 * ******************************************************************/
void dele_list(NODE** pHead)
{
    NODE* p=*pHead;
    NODE* pnext=NULL;//定义pnext,用于保存当前节点的next值
    if(NULL==*pHead)
    {
        printf("in dele_list,*pHead is NULL/n");
        return ;
    }
    while(p!=NULL)//防止最后一个节点没有被free!
    {
        pnext=p->next;
        free(p);
        p=pnext;
    }
  // *pHead==NULL;//不能写成这样!!!!!这个错误害得我调试了大半天!!!
    *pHead=NULL;//别忘了这一句！
    printf("dele_list success! well done!/n");
}
/*********************************************************************
 *函数名称：contrary_list
 *函数功能：将一个单向链表反转
 *函数参数：传入链表的头指针
 *返回值：  空
 * *******************************************************************/
void contrary_list(NODE* pHead)
{
    if(NULL==pHead)
    {
        printf("in contrary_list,pHead is NULL/n");
        return ;
    }
    if(NULL==pHead->next||NULL==pHead->next->next)
    {
        return ;
    }
    NODE* pdata=pHead->next;
    NODE* pdatanext=pdata->next;
    NODE* pend=pdatanext->next;
    pdata->next=NULL;
    do{
        pdatanext->next=pdata;
        pdata=pdatanext;
        pdatanext=pend;//调试正确前少写了这一句
        if(pend!=NULL)
        {
            pend=pdatanext->next;
        }
    }while(pdatanext!=NULL);
    pHead->next=pdata;
    printf("contrary_list success! well done!/n");
}
/****************************************************************
 函数名称：sort_list
 函数功能：对单向链表进行排序:(升序)
 函数参数：传入链表的头指针
 返回值：  空
*****************************************************************/
void sort_list(NODE* pHead)/排序(升序)
{
    if(NULL==pHead)
    {
        printf("in sortList, pHead is NULL/n");
        exit(-1);
    }

    if (NULL==pHead->next || NULL==pHead->next->next)
    {
        printf("in sortList, don't need to be sorted!/n");
        return ;
    }

    NODE* p=pHead;
    NODE* pData=pHead->next->next;
    NODE* pDataNext=pData->next;
    pHead->next->next=NULL;

    while(pData!=NULL)
    {
        p=pHead;
        while(p->next!=NULL)
        {
            if(pData->x >= p->next->x)
            {
                p=p->next;
                if(NULL==p->next)
                {
                    p->next=pData;
                    pData->next=NULL;
                    pData=pDataNext;
                    if(pDataNext!=NULL)
                    {
                        pDataNext=pDataNext->next;
                    }

                    break;
                }
            }
            else
            {
                pData->next=p->next;
                p->next=pData;
                pData=pDataNext;
                if(pDataNext!=NULL)
                {
                    pDataNext=pDataNext->next;
                }

                break;
            }
        }
    }
    printf("sortList success!/n");
}
/***********************************************************************
 *main函数
 * ********************************************************************/
int main(void)
{
    NODE node;
    NODE* listHead=NULL;
    init_list(&listHead);//初始化单向链表
   
    int num[5]={1,4,3,5,2};
    int i;
    printf("sizeof(num)=%d/n",sizeof(num));
    for(i=0;i<sizeof(num)/sizeof(num[0]);i++)
    {
        node.x=num[i];
        printf("node.x=%d/n",node.x);
        add_node(listHead,node);   //添加节点
    }
   
    display_list(listHead);//显示链表的数据
    find_node(listHead,2);//查找符合条件的一个节点
    del_node(listHead,2);//删除符合条件的一个节点
    display_list(listHead);
    sort_list(listHead);   //对单向链表进行排序
    display_list(listHead);//显示链表的数据
   // dele_list(&listHead);
    contrary_list(listHead);//将链表反转
    display_list(listHead); //显示链表的数据
    return 0;
}