数据结构之链表

离散存储【链表】

定义：

   n个节点离散分配

    彼此通过指针相连

    每个节点只有一个前驱节点，每个节点只有一个后继节点

    首节点没有前驱节点  尾节点没有后继节点

 

    专业术语：

       首节点：第一个有效节点

 　　尾节点：最后一个有效节点

 　　头指针：指向头节点的指针变量

 　　头节点：

  　　　　 头节点的数据类型和首节点的数据类型一样

     　　　　　　第一个有效节点之前的那个节点

           　　头节点并不存放有效数据

           　　加头节点的目的主要是为了方便对链表的操作

 　　尾指针：指向尾节点的指针变量

　　如果希望通过一个函数来对链表进行处理，我们至少需要接收链表的哪些参数：

　　　　只需要一个参数：头指针

　　　　因为我们通过头指针可以推算出链表的其他所有信息

# include<stdio.h>
 
 typedef struct Node
 {
     int data;//数据域
    struct Node * pNext;//指针域 
 }NODE,*PNODE;
 //NODE等价于struct Node   PNODE等价于struct Node *
 
 int main(void)
 {
     return 0;
 } 

分类：

　　单链表

　　双链表：每一个节点有两个指针域

　　循环链表：能通过任何一个节点找到其他所有的节点

　　非循环链表

　　算法：

　　　　狭义的算法是与数据的存储方式密切相关的

　　　　广义的算法是与数据的存储方式无关

　　泛型：

   　　  利用某种技术达到的效果就是：不同的存储方式，执行的操作是一样的

　　遍历

　　查找

　　清空

　　销毁

　　求长度

　　排序

　　删除节点

　　插入节点

链表的优缺点：

　　优点

    　　空间没有限制

    　　插入删除元素很快

　　缺点

   　　存取速度慢

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

typedef struct Node
{
    int data; //数据域
    struct Node * pNext; //指针域   pNext指向一个和它本身数据类型相同的下一个节点
}NODE, *PNODE; //NODE等价于struct Node    PNODE等价于struct Node *

//函数声明
PNODE create_list(void);  //创建链表
void traverse_list(PNODE pHead);  //遍历链表
bool is_empty(PNODE pHead);  //判断链表是否为空
int length_list(PNODE);  //求链表长度
bool insert_list(PNODE pHead, int pos, int val);  //在pHead所指向链表的第pos个节点的前面插入一个新的结点，该节点的值是val， 并且pos的值是从1开始
bool delete_list(PNODE pHead, int pos, int * pVal);  //删除链表第pos个节点，并将删除的结点的值存入pVal所指向的变量中,  并且pos的值是从1开始
void sort_list(PNODE);  //对链表进行排序


int main(void)
{
    PNODE pHead = NULL; //等价于 struct Node * pHead = NULL;
    int val;

    pHead = create_list();  //create_list()功能：创建一个非循环单链表，并将该链表的头结点的地址付给pHead
    traverse_list(pHead);
    
    //insert_list(pHead, -4, 33);
    if ( delete_list(pHead, 4, &val) )
    {
        printf("删除成功，您删除的元素是: %d
", val);
    }
    else
    {
        printf("删除失败!您删除的元素不存在!
");
    }

    traverse_list(pHead);
    
    //int len = length_list(pHead);
    //printf("链表的长度是%d
", len);

    //sort_list(pHead);
    //traverse_list(pHead);
    
/*    if ( is_empty(pHead) )
        printf("链表为空!
");
    else
        printf("链表不空!
");
*/
    return 0;
}

PNODE create_list(void)
{
    int len;  //用来存放有效节点的个数
    int i;
    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 (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;
    }
    
    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)
{
    int i, j, t;
    int len = length_list(pHead);
    PNODE p, q;
    
    for (i=0,p=pHead->pNext; i<len-1; ++i,p=p->pNext)
    {
        for (j=i+1,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;
}

//在pHead所指向链表的第pos个节点的前面插入一个新的结点，该节点的值是val， 并且pos的值是从1开始（链表不存在满）
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;

    //如果程序能执行到这一行说明p已经指向了第pos-1个结点,但第pos-1个节点是否存在无所谓
    //分配新的结点
    PNODE pNew = (PNODE)malloc(sizeof(NODE));
    if (NULL == pNew)
    {
        printf("动态分配内存失败!
");
        exit(-1);
    }
    pNew->data = val;
    
    //将新的结点存入p节点的后面
    PNODE q = p->pNext;
    p->pNext = pNew;
    pNew->pNext = q;

    return true;
}


//要删除pos节点，就要知道第pos-1个节点，所以p->pNext就是第pos节点，也就是待删除的节点
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;
    
    //如果程序能执行到这一行说明p已经指向了第pos-1个结点，并且第pos个节点是存在的
    PNODE q = p->pNext;  //q指向待删除的结点
    *pVal = q->data;  

    //删除p节点后面的结点，也就是将删除的节点后面的值赋给前一个节点
    p->pNext = p->pNext->pNext;
    
    //释放q所指向的节点所占的内存
    free(q);
    q = NULL;
    
    return true;

}