单链表的基础

单链表的设计

1.单链表的结构定义

typedef struct Node{

        int data;//数据域

        struct Node* next;//后继指针

}Node,*List;

2.单链表的设计示意图

3.注：单链表的最后一个节点的next域为NULL;

4.为什么用一个头结点（简单方便，不用传二级指针）

单链表的实现

//初始化
void InitList(List plist)
{
    assert(plist != NULL);
    if (plist == NULL)
        return;
    //plist->data;//头节点的数据域不使用
    plist->next = NULL;
}

//考试重点
//头插
bool Insert_head(List plist, int val)
{
    assert(plist != NULL);
    if (plist == NULL)
        return false;
    //动态申请一个节点
    Node* p = (Node *)malloc(sizeof(Node));
    assert(p != NULL);

    //将数据val放入到新节点
    p->data = val;

    //插入新节点
    p->next = plist->next;
    plist->next = p;

    return true;
}

//考试重点
//尾插
bool Insert_tail(List plist, int val)
{
    assert(plist != NULL);
    if (plist == NULL)
        return false;
    //申请节点
    Node* p = (Node*)malloc(sizeof(Node));
    assert(p != NULL);
    //将数据val放入到新节点
    p->data = val;
    //找尾巴
    Node* q;
    for(q=plist;q->next!=NULL;q=q->next)
   {
        ;
    }
    //插入新节点
    p->next = q->next;//p->next=NULL;
    q->next = p;
    return true;
}

//插入数据，在plist链表的pos位置插入val;
bool Insert(List plist, int pos, int val)
{
    assert(plist != NULL);
    if (plist == NULL)
        return false;

    if (pos<0 || pos>GetLength(plist))
    {
        return false;
    }
    Node* p = (Node*)malloc(sizeof(Node));
    assert(p != NULL);
    p->data = val;
    //找到位置
    Node* q;
    int i;
    for (q = plist, i = 0; i < pos; i++, q = q->next)
    {
        ;
    }
    // 插入
    p->next = q->next;
    q->next = p;

    return true;
}

//判空
bool IsEmpty(List plist)
{
    assert(plist != NULL);
    if (plist == NULL)
        return false;

    return plist->next == NULL;
}

//获取数据节点的个数
int GetLength(List plist)
{
    assert(plist != NULL);
    if (plist == NULL)
        return 0;
    int count = 0;
    for (Node* p = plist->next; p!= NULL; p = p->next)
    {
        count++;
    }
    return count;

}

//在plist中查找第一个key值，找到返回节点地址，没有找到返回NULL；
Node* Search(List plist, int key)
{
    assert(plist != NULL);
    if (plist == NULL)
        return NULL;
    
    for (Node* p = plist->next; p != NULL; p = p -> next)
    {
        if (p->data == key)
        {
            return p;
        }
    }
    return NULL;
}

//删除pos位置的值
bool DelPos(List plist, int pos)
{
    assert(plist != NULL);
    if (plist == NULL)
        return false;
    if (pos < 0 || pos >= GetLength(plist))
    {
        return false;
    }
    Node* p;
    int i;
    for (p = plist, i = 0; i < pos; i++, p = p->next)
    {
        ;
    }
    //删除p后面的节点
    Node* q = p->next;
    p->next = q->next;
    free(q);

    return true;
}

//考试重点
//删除第一个val的值
bool DelVal(List plist, int val)
{
    Node* p = GetPrio(plist, val);
    if (p == NULL)
        return false;
    Node* q = p->next;
    //删除q
    p->next = q->next;//p->next=p->next->next;
    //释放q
    free(q);

    return true;
}

//返回key的前驱地址，如果不存在返回NULL；
Node* GetPrio(List plist, int key)
{
    for (Node* p = plist; p->next != NULL; p = p->next)
    {
        if (p->next->data == key)
            return p;
    }
    return NULL;
}

//返回key的后继地址，如果不存在返回NULL；
Node* GetNext(List plist, int key)
{
    assert(plist != NULL);
    if (plist == NULL)
        return NULL;

    Node* p = Search(plist, key);
    if (p == NULL)
        return NULL;

    return p->next;
}

//输出
void Show(List plist)
{
    //注意，头节点不能访问data
    for (Node* p = plist->next; p != NULL; p = p->next)
    {
        printf("%d ", p->data);
    }
    printf("\n");
}

//清空数据
void Clear(List plist)
{
    Destroy(plist);
}

void Destroy(List plist)
{
    //总是删除第一个数据节点
    Node* p;
    while (plist->next != NULL)
    {
        p = plist->next;

        plist->next = p->next;

        free(p);

        //error
        //plist->next = plist->next->next;
        //free(plist->next);
    }
}

单链表的总结

1.单链表的特点：
头插，头删 时间复杂度是O(1)
尾插，尾删 时间复杂度是O(n)(有个for循环找结尾)

2.P初始化成什么?

如果我们要修改表的结构(或者说依赖于前驱,比如插入,删除):遍历:

for(Node *p=plist;p->next!=NULL;p=p->next)

如果我们不修改表的结构(或者说不依赖于前驱, 比如求长度,打印,查找) :遍历:

for (Node* p = plist->next; p != NULL; p = p->next)

单链表的其他函数

1.链表的逆置

方法一：（复杂）

//试写一算法，对单链表实现就地逆置，
void Reverse1(List plist)//太复杂
{
    assert(plist != NULL);
    if (plist == NULL||plist->next==NULL||plist->next->next==NULL)
        return;

    Node* p = plist->next;//前面的点;
    Node* q = p->next;//后面的点;
    Node* r;//后面所有还未处理的第一个点;

    p->next = NULL;
    while (q != NULL)
    {
        r = q->next;
        q->next = p;//向后转
        p = q;
        q = r;
    }
    plist->next = p;
}

方法二：

void Reverse(List plist)
{
    assert(plist != NULL);
    if (plist == NULL || plist->next == NULL || plist->next->next == NULL)
        return;

    Node* p = plist->next;
    Node* q = p->next;

    plist->next = NULL;//断开

    //利用头插把节点插入到链表中
    while (p != NULL)
    {
        q = p->next;

        p->next = plist->next;//头插
        plist->next = p;

        p = q;
    }
}

2.链表中的两个面试题目:

1．只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。       
2．只给定单链表中某个结点p(非空结点)，在p前面插入一个结点。
    
解析1:无法删除,因为删除依赖前驱;但是可以通过删除p的后继,当然在删除后继之前将后继节点的数据域复制到p的数据域:
p->data=p->next->data; 
Node *q=p->next;
p->next=p->next->next;
free(q);

解析2:前面没有办法插入,因为不知道前驱;
但是可以在后面插入,然后将两个值交换即可;
设插入的节点为q,q->next=p->next;p->next=q;
交换数据:int  tmp=p->data;p->data=p->next->data;p->next->data=tmp;