关于单链表的位序插入详情（带头结点）

最近学习数据结构，对单链表的位序插入有了更加深切的理解

以下是代码详情：

typedef struct LNode{

    ElemType data;

    struct LNode *next ;

   }LNode,*LinkList;

链表的定义

详情代码：

//在第i个位置插插入元素e (带头结点)

   bool ListInsert(LinkList &L, int i, ElemType e){//找到第i-1个结点，将新结点插入其后 

    if(i<1)

    return false;

    LNode *p; //指针p指向当前扫描到的结点

    int j=0; //当前p指向的是第几个结点

    p =L; //L指向头结点，头结点是第0个结点(不存数据)

    while (p!=NULL && j<i-1) { //循环找到第 i-1个结点

      p=p->next;

      j++;

    }

    if(p==NULL)  //i值不合法

    return false;

    LNode *s = (LNode *)malloc (sizeof(LNode));

    s->data = e;

    s->next=p- >next ;

    p->next=s;     //将结点s连到p之后

    return true;    //插入成功

/*解题思路：

1. 如果我们需要在第二个位置插入一个新的结点

1. 首先我们需要找到第一个结点：

1. 然后让malloc申请一个新的空间结点

04.在新申请的结点中插入想插入的元素e

05.对指针进行修改：让新结点e指针指向结点a2

06. 对指针进行修改:让a1指针指向新开辟的结点e

若想在i=1的位置插入新结点,则带头结点链表更加方便,我们可以将头结点看做是第零个结点,然后依照上述处理逻辑,也是可以解决这个问题的

思路

    首先定义一个函数包含三个参数: (LinkList &L(插入的表), int i(插入的位序), ElemType e(插入的元素))

1. ListInsert(LinkList &L(插入的表), int i(插入的位序), ElemType e(插入的元素))

   分析:

     01: 如果i=1(插在表头)

      if(i<1) 传入参数不合法,位序是从1开始的，头结点的编号是从1开始的所以我们不允许i值小于1

      return false;

     

01.1 初始链表

     

02:

        LNode *p; //声明一个指针p,指针p指向当前扫描到的结点

         int j=0; //当前p指向的是第几个结点(头结点可以看成是第零个结点(实际上是没有第零个结点,只是将头结点看做零个结点))

         p =L; //指针p指向了和l相同的位置,也就是指向了头结点,L指向头结点，头结点是第0个结点(不存数据)

        

      03:

     LNode *s = (LNode *)malloc (sizeof(LNode));  申请一个新的结点空间

      s->data = e;  将参数e存在新的结点里面

       s->next=p->next    让s指向的结点next指针让它等于p结点的next指针指向的位置

       p->next=s  让p指向的结点next指针指向s

        时间复杂度则为:O(1)

       s->next=p- >next ;

          p->next=s;   这两句位置不能颠倒,位置颠倒则会指向本身

    04:如果i=3(插在表中)

    先进行以下操作:

        LNode *p; //声明一个指针p,指针p指向当前扫描到的结点

         int j=0; //当前p指向的是第几个结点(头结点可以看成是第零个结点(实际上是没有第零个结点,只是将头结点看做零个结点))

         p =L; //指针p指向了和l相同的位置,也就是指向了头结点,L指向头结点，头结点是第0个结点(不存数据)

        

    //此时i-1=2 而前面int j=0 此时j=0

    进行while循环  

        while (p!=NULL && j<i-1) {  此时p!=null 并且j<2

           p=p->next;   让p指向下一个结点 此时  j<2-1  j任然<i j++,循环继续  j->0->1->2 循环结束

          j++;

     05:如果i=5(插在表尾)

    先进行以下操作:

        LNode *p; //声明一个指针p,指针p指向当前扫描到的结点

         int j=0; //当前p指向的是第几个结点(头结点可以看成是第零个结点(实际上是没有第零个结点,只是将头结点看做零个结点))

         p =L; //指针p指向了和l相同的位置,也就是指向了头结点,L指向头结点，头结点是第0个结点(不存数据)

        

    //此时i-1=4 而前面int j=0 此时j=0

最后p=null，循环判断不满足，循环结束

    进行while循环  

        while (p!=NULL && j<i-1) {  此时p!=null 并且j<4

           p=p->next;   让p指向下一个结点 此时  j<5-1  j任然<i j++,循环继续  j->0->1->2->3->4循环结束

          j++;

        

时间复杂度则为:O(n )

   06:如果i=6(i>length)

    先进行以下操作:

        LNode *p; //声明一个指针p,指针p指向当前扫描到的结点

         int j=0; //当前p指向的是第几个结点(头结点可以看成是第零个结点(实际上是没有第零个结点,只是将头结点看做零个结点))

         p =L; //指针p指向了和l相同的位置,也就是指向了头结点,L指向头结点，头结点是第0个结点(不存数据)

        

    //此时i-1=5 而前面int j=0 此时j=0

    进行while循环

     while (p!=NULL && j<i-1) {  此时p!=null 并且j<5

           p=p->next;   让p指向下一个结点 此时  j<6-1  j任然<i j++,循环继续  j->0->1->2->3->4->null循环条件不满足,循环结束

          j++;   

}

最后p=null，循环判断不满足，循环结束

再判断p==null，表明第i-1个结点不存在，无法插入数据，所以直接返回一个false

   */

时间复杂度则为:O(n )

这篇文章：以上为主要思路，具体代码如下：

#include <stdio.h>
#include<stdlib.h>
typedef struct LNode{ //定义单链表结点类型 
    int data;  //数据域 
    struct LNode *next; //指针域 (为什么next指针域要定义为struct LNode呢，)
}LNode, *LinkList;
 //(为什么next指针域要定义为struct LNode呢?)
//next指针用来指向链表的下一个结点，该结点同样为一个LNode结构体，
//因此next要声明为指向LNode结构体的指针struct LNode*
bool InitList(LinkList &L)
{
    L = (LNode *)malloc(sizeof(LNode));
    if(L == NULL)
        return false;
    L->next = NULL;
    return true;
} 

//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L, int i, int e){  
    //判断i的合法性, i是位序号(从1开始)
    if(i<1)
        return false;
    
    LNode *p;       //指针p指向当前扫描到的结点 
    int j=0;        //当前p指向的是第几个结点
    p = L;          //L指向头结点，头结点是第0个结点（不存数据）

    //循环找到第i-1个结点
    while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULL
        p = p->next;             //p指向下一个结点
        j++;
    }

    if (p==NULL)                 //i值不合法
        return false;
    
    //在第i-1个结点后插入新结点
    LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点
    s->data = e;
    s->next = p->next;
    p->next = s;                 //将结点s连到p后,后两步千万不能颠倒qwq

    return true;
}

void test()
{
    LinkList L;
    if(InitList(L))
        printf("true");
    printf("\n");
    
    ListInsert(L,1,3);
    ListInsert(L,2,5);
    LNode *s = L->next;
    
    while(s)
    {
        printf("%d ",s->data);
        s = s->next;
    }
    return;
}

int main(void)
{
    test();
    return 0;
}