单链表的插入删除

单链表的插入和删除

ListInsert(&L,i,e):插入操作，在表L中的第i个位置上插入指定元素e，（找到第i-1个结点，将新节点插入其后）

按位序插入（带头结点）

存在第0个结点

//在第i个位置插入元素e（带头结点）
bool LIstInsert(LinkList &L,int i,ElemTYpe e){
	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;//让p=p的指针，就是让p指向下一个节点
        j++;
    }
    if(p==NULL)//i值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;//申请一个新的结点空间，把参数e存到参数空间里面
    s->next=p->next;//指针p后移，s结点的next指向下一个节点的数据域，p指向ai，p->next指向ai+1
	p->next=s;//将结点s连到p之后，p节点的next指向s的数据域
    return true;//插入成功
}

1. i=1，插在表头

   最好时间复杂度：O(1)

    s->next=p->next;
    p->next=s;

上面两行代码不能颠倒，若颠倒指针就和指向它自己

2. 最坏时间复杂度：O(n)

   i=n,插在表尾

3. 平均时间复杂度：O(n)

按位序插入（不带头结点）

不存在第0个结点

ListInsert(&L,i,e)：插入操作，在表L中的第i个位置上插入指定元素e

如果不带头结点，则插入。删除第1个元素时，需要更改头指针L

bool ListInsert(LinkList &L,int i,ElemType e){
	if(i<1)
        return false;
    if(i==1){//插入第1个结点的操作与其他结点操作不同
        LNode *s=(LNode *)malloc(sizeof(LNode));
        s->data=e;//在s的数据域里面存放e
        s->next=L;//s的指针域指向L
        L=s;//L指向s
        return true;
    }
    LNode *p;//指针p指向当前扫描到的结点
    int j=1;//当前p指向的是第几个结点，和带头结点不同的地方
    p=L;//L指向头结点，头结点是第0个结点（不存数据）
    while(p!=NULL &&  j<i-1){//循环找到第i-1个结点
        p=p->next;//让p=p的指针，就是让p指向下一个节点
        j++;
    }
    if(p==NULL)//i值不合法
        return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;//申请一个新的结点空间，把参数e存到参数空间里面
    s->next=p->next;//指针p后移，s结点的next指向下一个节点的数据域，p指向ai，p->next指向ai+1
	p->next=s;//将结点s连到p之后，p节点的next指向s的数据域
    return true;//插入成功
}
}

除非特殊声明，之后的代码默认带头结点

指定结点的后插操作 O(1）

//后插操作：在p结点之后插入元素e
bool InsertNextNode(LNode *p,ElemType e){
	if(p==NULL)
        return false;
    LNode *S=(LNode *)malloc(sizeof(LNode));
    if(s==NULL)//内存分配失败，如：内存不足
        return false;
    s->data=e;//用结点s保存数据元素e
    s->next=p->next;
    p->next=s;//将结点s连到p之后
    return true;
}

指定结点的前插操作

//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p,ElemType e)
    
//传入头指针,循环查找p的前驱q，再对q后插
bool InsertPriorNode(LinkList L,LNode *p,ElemTYpe e)

上面时间复杂度O(n)，传入头指针太繁琐，我们采用将p的元素复制到s中，然后将p中的元素覆盖

//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p,ElemType e){
    if(p==NULL)
        return false;
    LNode *S=(LNode *)malloc(sizeof(LNode));
    if(s==NULL)//内存分配失败，如：内存不足
        return false;
    s->next=p->next;//插入后继结点s
    p->next=s;//s连接到p之后
    s->data=p->data;//将p中的元素复制到s中
    p->data=e;//p中元素覆盖为e
    return true;
}

时间复杂度O(1)，偷天换日法，妙不可言，还可以找个临时变量，本质是一样的

bool InserPriorNode(LNode *p,LNode *s){
    if(p==NULL||s==NULL)
        return false;
    s->next=p->next;
    p->next=s;//s连到p之后
    ElemType temp=p->data;//交换数据域部分
    p->data=s->data;
    s->data=temp;
    return true;
}

按位序删除（带头结点）

ListDelete（&L,i,&e）：删除操作，删除表L中第i个位置的元素，并用e返回删除元素的值

• 找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点

bool LIstDelete(LinkLIst &L,int i,ElemType &e){
    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指向第i-1个结点
        p=p->next;
        j++;
    }
    if(p==NULL)//i值不合法
        return false;
    if(p->next==NULL)//第i-1个结点之后已无其他结点
        return false;
    LNode *q=p->next;//令q指向被删除的结点，q结点指向p的next，也就是指向第i个结点
    e=q->data;//把q里面的数据元素复制到e里面
    p->next=q->next;//p的next指向q的next，就是指向NULL。将*q结点从链中断开
    free(q);//释放结点的存储空间
    return true;//删除成功
}

最坏、平均时间复杂度：O(n)

最好时间复杂度：O(1)->要删除第一个节点的时候

指定结点的删除

//删除指定结点p
bool DeleteNode(LNode *p){
    if(p==NULL)
        return false;
    LNOde *q=p->next;//令q指向P的后继结点
    p->data=p->next->data;//和后继结点交换数据域，把p结点后继结点的数据元素复制到p结点的数据域里面
    p->next=q->next;//将q结从链中断开，q的后记结点可能是一个结点，也可能使NULL
    free(q);//释放后继结点后的存储空间
    return true;
}

时间复杂度：O(1)

单链表局限性：无法逆向检索，有时不太方便