单链表实现

单链表实现

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

typedef struct Node
{
    int data;  //数据域
    struct Node * pNext;  //指针域 
}NODE, *PNODE;   //NODE等价于struct Node，PNODE等价于struct Node *  

//函数声明 
PNODE creat_list();
void traverse_list(PNODE pHead);
bool is_empty(PNODE pHead);
int length_list(PNODE pHead);
bool insert_list(PNODE pHead,int pos,int val); 
bool delete_list(PNODE pHead,int,int*); 
void sort_list(PNODE pHead);

int main()
{
    PNODE pHead = NULL;  //等价于struct Node * pHead = NULL；头结点 
    int val;
    
    pHead = creat_list();
    traverse_list(pHead);
    if( is_empty(pHead) )
        printf("链表为空
");
    else
        printf("链表不空
"); 
    int len = length_list(pHead);
    printf("链表长度是%d
",len);
    
    if( insert_list(pHead,4,33) )
    {
        printf("第四个节点插入数据成功!
"); 
    } 
    else
    {
        printf("插入失败!
");
    }
    traverse_list(pHead);
    
    if( delete_list(pHead,4,&val) )
    {
        printf("删除成功，您删除的元素是:%d
",val); 
    } 
    else
    {
        printf("删除失败！您删除的元素不存在!
");
    }
    traverse_list(pHead);
    
    sort_list(pHead);
    printf("链表由小到大排序
");
    traverse_list(pHead);
    
    return 0;
} 

PNODE creat_list()
{
    int len;   //用来存放有效节点的个数 
    int val;   //用来临时存放用户输入节点的值
    
    PNODE pHead = (PNODE)malloc(sizeof(NODE));
    if(NULL == pHead)
    {
        printf("分配失败,程序终止"); 
        exit(-1);
    } 
    PNODE pTail = pHead;  
    pTail->pNext = NULL;
    
    printf("请输入您需要生成的链表节点的个数:len = ");
    scanf("%d",&len);
    
    for(int i=0;i<len;++i)
    {
        printf("请输入第%d个节点的值:",i+1);
        scanf("%d",&val);
        
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if(NULL == pNew)
        {
            printf("分配失败,程序终止"); 
            exit(-1);
        } 
        pNew->data = val;   //尾插法 
        pTail->pNext = pNew;
        pNew->pNext = NULL;
        pTail = pNew;  //pTail在不断的移动，相当于指向要插入节点上一个节点指针 
    }
    return pHead; 
}

void traverse_list(PNODE pHead)
{
    PNODE p = pHead->pNext;
    while(NULL != p)
    {
        printf("%d ",p->data);
        p = p->pNext;
    }
    printf("
");
    return;
} 

bool is_empty(PNODE pHead)
{
    if(NULL == pHead->pNext)
        return true;
    else
        return false;
}

int length_list(PNODE pHead)
{
    PNODE p = pHead->pNext;
    int len=0; 
    while(NULL != p)
    {
        ++len;
        p = p->pNext;
    }
    return len;
}

void sort_list(PNODE pHead)   //选择排序算法 
{
    PNODE p,q; 
    int i,j,t;
    int len = length_list(pHead);
    
    for(i=0,p=pHead->pNext;i<len-1;++i,p=p->pNext)
    {
        for(j=0,q=p->pNext;j<len;++j,q=q->pNext)
        {
            if(p->data > q->data)   //类似于数组中的:a[i]>a[j] 
            {
                t = p->data;//类似于数组中的:t = a[i];
                p->data = q->data;//类似于数组中的:a[i] = a[j];
                q->data = t;//类似于数组中的:a[j] = t;
            } 
        }
    }
    return;
}

bool insert_list(PNODE pHead,int pos,int val)
{
    int i=0;
    PNODE p = pHead;
    
    while(NULL!=p && i<pos-1)
    {
        p = p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL==p)
        return false;
        
    PNODE pNew =(PNODE)malloc(sizeof(NODE));
    if(NULL == pNew)
    {
        printf("动态分配内存是啊比!
");
        exit(-1);
    }
    pNew->data = val;
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;
    return true;
}

bool delete_list(PNODE pHead,int pos,int* pVal)
{
    int i=0;
    PNODE p = pHead;
    
    while(NULL!=p->pNext && i<pos-1)
    {
        p = p->pNext;
        ++i;
    }
    if(i>pos-1 || NULL==p->pNext)
        return false;
        
    PNODE q = p->pNext;   //将要删除的节点赋值给临时指针q 
    *pVal = q->data;
    
    //删除p节点后面的节点
    p->pNext = p->pNext->pNext;
    free(q);
    q = NULL; 
    return true;    
}