单链表的实现

1、单线表的存储结构

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

2、单线表的初始化

//创建链表
PNODE create_list(){
    int len;//用来存放节点的个数
    int i;
    int  val;//用来临时存放用户输入的节点的值

    //头结点
    PNODE pHead=(PNODE)malloc(sizeof(NODE)); 
    //如果为NULL，则分配失败
    if(NULL==pHead){
        printf("分配失败，程序终止");
        exit(-1);
    } 

    //空链表时，使头节点和尾节点都相等，且尾节点的指针域为NULL 
    PNODE pTail=pHead;
    pTail->pNext=NULL; 

    printf("请输入您需要生成的链表节点的个数:len=");
    scanf("%d",&len);

    if(len<0){
        printf("你输入链表长度不合法！请重新输入："); 
        scanf("%d",&len);
    } 

    for(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的数据域 
        pNew->data=val;
        //让尾节点的指针域指向pNew 
        pTail->pNext=pNew;
        //将pNew变成尾节点 
        pNew->pNext=NULL;
        pTail=pNew;
    }
    return pHead;
} 

3、遍历单链表

//遍历链表
void traverse_list(PNODE pHead){
    PNODE p=pHead->pNext;
    if(is_empty_list(pHead)){
        printf("链表为空\n");
        return;
    }
    while(NULL!=p){
        printf("%d ",p->data);
        p=p->pNext;
    }
    printf("\n"); 
} 

4、链表是否为空

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

5、链表长度

int length_list(PNODE pHead){

    int len=0;
    PNODE p=pHead->pNext;

    while(NULL!=p){
        len++;
        p=p->pNext;
    }
    return len;
}

6、冒泡排序

void sort_list(PNODE pHead){

    PNODE p,q;
    int temp;
    //遍历链表，比较大小，直到p中的指针域为NULL就停止遍历 
    for(p=pHead->pNext;p!=NULL;p=p->pNext){
        for(q=p->pNext;q!=NULL;q=q->pNext){
            //如果p数据域的值大于q数据域的值 
            if(p->data > q->data){
                //交换q，p数据域的值 
                temp=p->data;
                p->data=q->data;
                q->data=temp;
            }
        }
    }
}

7、插入

// 在pHead所指向的链表中第index节点之前插入一个新的节点，该节点的值为val。 
bool insert_list(PNODE pHead,int index,int val){

    int i=0;
    //保存头指针 
    PNODE p=pHead;

    //分配新内存，新节点。 
    PNODE pNew=(PNODE)malloc(sizeof(Node));
    if(NULL==pNew){
        printf("动态分配内存失败");
        exit(-1);
    } 

    //通过循环，使p指向index位置的节点 
    while(NULL!=p&&i<index-1){
        p=p->pNext;
        i++;
    } 

    if(i>index-1||NULL==p){
        printf("已经超出插入范围") ; 
        return false;
    } 

    //保存插入的val 
    pNew->data=val;

    /*pNew头部先插入 的方式 
    PNODE  temp=p->pNext;
    p->pNext=pNew;
    pNew->pNext=temp;
    */

     //pNew尾部先插入 
     pNew->pNext=p->pNext;
     p->pNext=pNew; 
    return true;
} 

8、删除

bool detele_list(PNODE pHead,int index,int *pVal){
    int i=0;
    PNODE p=pHead;


    //通过遍历，使ｐ指向ｉｎｄｅｘ前面的节点 
    //如果 p->pNext==null，后面就没有节点了 
    while(NULL!=p->pNext&&i<index-1){
        p=p->pNext;
        i++;
    } 

    if(i>index-1||NULL==p->pNext)
        return false;

    //临时保存要删除节点的内存  
    PNODE q=p->pNext;
    //将删除的节点中的数据保存起来 
    *pVal=q->data;
    //将要删除节点前面的节点的指针域，指向要删除节点的下一个节点 
    p->pNext=p->pNext->pNext;
    //释放要删除节点的内存
    free(q);
    q=NULL;

    return true;
} 

9、获取第index位置的数据

int getElem(PNODE pHead,int index){

    //保存找到的数据 
    int  temp;
    //计数器 
    int j=1;

    PNODE p=pHead->pNext;
    //判断数据表是否为空 
    if(is_empty_list(pHead)){
        printf("链表为空！");
        exit(-1); 
    }
    //如果查询的位置大于链表的长度 
    //length_list(p)测试链表的长度 
    if(index>length_list(p)){
        printf("所找的位置不存在！");
        exit(-1);
    } 

    //循环遍历，直到找到第index位置的数据的指针 
    while(j<index){

        p=p->pNext;
        j++;
    } 


    temp=p->data;

    return temp;

} 

10、清空链表的数据

bool clearList(PNODE pHead){

    //判断链表是否为空 
    if(is_empty_list(pHead)){
        printf("链表为空！\n"); 
        return false;
     } 


    PNODE p,q;

    p=pHead;

    while(p){
        q=p->pNext;
        free(p);
        p=q;
    }

    pHead->pNext=NULL;
} 

测试代码：

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

//函数声明 
PNODE create_list(void); 
void traverse_list(PNODE pHead);
bool is_empty_list(PNODE pHead);
int length_list(PNODE pHead); 
void sort_list(PNODE pHead); 
bool insert_list(PNODE pHead,int index,int val);
bool detele_list(PNODE pHead,int index,int *pVal);
int getElem(PNODE pHead,int index);
bool clearList(PNODE pHead); 

int main()
{
    //保存删除的数据 
    int pVal;

    //创建链表 
    PNODE p=create_list();
    //遍历链表 
    printf("链表遍历！\n");
    traverse_list(p);

    //输入链表长度 
    //printf("链表长度len=%d\n",length_list(p));

    //冒泡排序
     sort_list(p); 
     printf("冒泡排序后的链表遍历！\n");
     traverse_list(p);

     //插入999到第四个位置 
      insert_list(p,4,999); 
     printf("插入后的链表遍历！\n");
      traverse_list(p);

      //删除数据 
      if(detele_list(p,1,&pVal)){
        printf("\n删除的数据是pval=%d\n",pVal);
      }else{
        printf("你删除的值不存在\n");
      } 
       printf("删除后的链表遍历！\n");
      traverse_list(p); 

      //找到第三位置的数 
      printf("第三位置的数的数是%d\n",getElem(p,3));

      //清空链表
      clearList(p);
      traverse_list(p);  
      return 0;
}

测试结果：

源代码下载：http://download.csdn.net/detail/a_person_alone/9487926