LinkList 基础操作

/*****  
    Step0.链表节点的定义
        typedef struct Node
        {
            int val;
            int *next;
        }Node;
    
    Step1. 链表的建立
        函数：void* malloc (size_t size);
        单个节点的创建:
        
        初始化：

        Node *createOneNode(int val)
        {
            Node *n = (Node *)malloc(sizeof(Node));
            n->val = val;
            n->next = NULL;
        }

    Step2. 连个节点连接起来.
        n1->next = n2;

    Step3.  遍历所有的节点（带头节点）。
        void traverse(Node *head)
        {
            Node *p = head->next;
            while (p!=NULL)
            {
                printf("%d ", p->val);
                p = p->next;
            }
        }
            
    Step4. 查找一个节点，为了方便后续的删除，返回查找到节点的前驱节点。
        Sample:   head->1->2->3->NULL;
            查找2时，返回结果为1的地址q，
            假如2的地址为comp， 删除的时候，只需要，
            1. q->next = q->next->next;  //把3的地址赋给了1的下一个节点，2就删除了。
            2.记得释放2的空间  free(comp);

        Node *find(Node *head, val)
        {
            if (head==NULL)
                return ;
            Node *q = head;
            Node *comp = head->next;
            while (comp!=NULL && comp->val != val)
            {
                q = comp;
                comp = comp->next;
            }

            if (comp==NULL)
                return NULL;
            
            return q;
        }

    Step5.删除一个节点。
        先找到要删除节点的父节点。
        void delNode(Node *head, int val)
        {
            if (head==NULL)
                return ;
            Node *q = find(head, val);
            if  (q==NULL)
                return ;
            else 
            {
                Node *deln = q->next;//先保存下要删除的节点
                q->next = deln->next;//将要删除节点的下一个节点赋给父节点指针的下一个节点，3的地址赋给1->next；
                //上一段代码等同  q->next = q->next->next;
                free(deln);//释放掉要删除的节点。
            }
        }
            
    Step6.插入一个节点
        头插法、尾插法、任意位置插入。

        void headInsert(Node *head, Node *innode)
        {
            if (head == NULL || innode==NULL)
                return ;
            Node *tnext = head->next;//先保存下来头节点的下一个节点。
            head->next = innode;//更换头节点的下一个节点。
            innode->next = tnext;//将新加进入的节点连接到原来头节点后面的节点。
        }


        void tailInsert(Node *head, Node *innode)
        {
            if (head==NULL || innode==NULL)
                return ;
            //找到尾节点的前一个节点.

            Node *front = head;
            Node *index = head->next;
            while (index!=NULL)
            {
                front = index;
                index = index->next;
            }

            front->next = innode;
        }
****/



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

typedef struct Node 
{
    int val;
    Node *next;
}Node;

Node *createOneNode(int val)
{
    Node *p = (Node *)malloc(sizeof(Node));
    p->val = val;
    p->next = NULL;
    return p;
}

//返回查找到节点的前驱节点
Node *findNode(Node *head, int val)
{
    if (head == NULL)
        return NULL;
    Node *pre = head;
    Node *back = head->next;
    while (back != NULL && back->val != val)
    {
        pre = back;
        back = back->next;
    }

    if (back == NULL)
        return NULL;
    return pre;
}

void  delOneNode(Node *head, int val)
{
    Node *pre = findNode(head, val);
    if (pre == NULL)
        return ;
    Node *save = pre->next;
    pre->next = save->next;
    free(save);
}

void headInsert(Node *head, Node *innode)
{
    if (head == NULL || innode == NULL)
        return ;
    Node *save = head->next;
    head->next = innode;
    innode->next = save;
}

void tailInsert(Node *head, Node *innode)
{
    if (head==NULL || innode==NULL)
        return ;
    //找到尾节点的前一个节点.

    Node *front = head;
    Node *index = head->next;
    while (index != NULL)
    {
        front = index;
        index = index->next;
    }

    front->next = innode;
}

void showNodes(Node *head)
{
    if (head == NULL)
        return ;
    Node *p = head->next;
    while (p != NULL)
    {
        printf(" %d", p->val);
        p = p->next;
    }
    printf("\n");
}
void insertBefore(Node *head, int val, Node *innode)
{
    ;   
}
int main()
{
    Node *head = createOneNode(0);
    Node *pt = NULL;
    int i = 0;
    for (i=1;i<=10; ++i)
    {
        pt = createOneNode(i);
        headInsert(head, pt);
    }

    delOneNode(head, 5);
    showNodes(head);
    delOneNode(head, 10);
    showNodes(head);
    delOneNode(head, 1);
    showNodes(head);
    return 0;
}

以上都是带头节点的情况，
如果应用过程中，不存在头节点，可以自己申请一个节点，作为头节点，然后让它连接到，原本链表的第一个节点。

Node  *prefirstNode = createOneNode(10);//10随意值
Node  *auxHead = createOneNode(0);//
auxHead->next = prefirstNode;

这样，上面的函数就可以传入 auxHead了。
留一个函数，在某一节点前插入，给读者实现。