C语言（基础）学习笔记⑩--链表（List）

1、静态链表

头指针、头节点等数据都在栈上。

1.1 链表节点定义

（1）数据域：我们要存储的数据在此

（2）指针域：指针指向下一个节点，下一个节点的类型就是本类型。

typedef struct node 
{
    int data;
    struct node * next;
}Node;

指针指向问题：指针指向谁，就保存谁的地址。

1.2 遍历逻辑

1. 当前指针指向第一个元素，并且不为空

2. 打印第一个元素的值，同时能得到第二个元素的地址

3. 第二个元素的地址 赋值给当前指针。

Node * pHead = head;

while(pHead)
{
    printf("%d\n", pHead->data);
    pHead = pHead->next;
}

2、动态链表

只有头指针在栈上，其他数据都在堆上。

加入头节点的目的，是对于链表的所有操作，不需要更新头指针。

2.1 链表创建

1 尾插法

在尾节点插入，每插入一个节点，即成尾节点。

cur->data = nodeData;   //新来数据
t->next = cur;   //将尾节点指向新来的节点
t = cur;         //让t指向尾节点

2 头插法

在头节点后面插入元素，每插入一个元素，即为首节点。

让新来的节点先有所指向，避免打断原有的指向；

cur->next = head->next;
head->next = cur;

3 链表求长

int lenList(Node *head)
{
    int len = 0;
    head = head->next; //带头节点，即数据为空的，在首节点之前的节点。
    while(head)
    {
        len++;
        head = head->next;
    }
    return len;
}

4 插入

带头节点的链表，插入元素时，即便新插入的元素成为首元素，不需要更新头节点指针。

void insertList(Node *head, int insertData)
{
    Node *cur = (Node *)malloc(sizeof(Node));
    cur->data = insertData;
    cur->next = head->next;
    head->next = cur;
}

5 查找

遍历， 匹配， 返回

Node * serachList(Node * head, int findData)
{
    head = head->next;

    while(head)
    {
        if(head->data == findData)
            break;
        head = head->next;
    }
    return head;
}

6 删除

带头节点的链表删除元素时，即便删除链表的首元素，也是删除头节点后第一个元素，不需要更新表头指针。

void deleteNodeOfList(Node * head, Node * pfind)
{
    if(pfind->next == NULL)
    {
        while(head->next != pfind)      //找到pfind节点的前驱
            head = head->next;
        head = head->next;

        free(pfind);
        pfind = NULL;
    }        
    else
    {
        //把pfind后一个数据赋值给pfind，然后将pfind->next指向pfind->next->next
        Node *t = pfind->next;
        pfind->data = pfind->next->data;
        pfind->next = pfind->next->next;
        free(t);
    }
}

7 排序

框架结构与冒泡排序相似

void popSortList(Node *head)
{
    int len = lenList(head);
    head = head->next;
    Node *p, *q;

    for(int i = 0; i < len-1; i++)
    {
        p = head;    //每次内重循环从头开始
        q = p->next; //q总是指向p的下一个节点，也就是被比较的节点。
        for(int j = 0; j < len - 1 - i; j++)
        {
            if(p->data > q->data)
            {
                p->data ^= q->data;
                q->data ^= p->data;
                p->data ^= q->data;
            }
            p = p->next;
            q = q->next; 
        }
    }
}