2.2.单链表的插入删除

图片来自B站王道考研（侵删）

插入

1.按位序插入（带头结点）

//在第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个结点			   }	第i-1个
        p->next;//												}		结点
        j++;//													}
    }
    if(p==NULL)		//i值不合法，从此行开始到下面结束，是为了在找到第i-1个节点之后，插入一个新的节点
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));//这一步malloc函数回升请一个新的结点
    s->data = e;	//将元素e装入到新的结点中
    s->next = p->next;	//原本p->null的，现在将新申请的结点s也指向p结点指向的下一个结点null
    p->next = s;	//将节点s连接到p之后（也就是将p指向s）
    return true;	//插入成功
}

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

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

bool LintInsert(LinkList &L,int i,ElemType e){
    if(i<1)
        return false;
    if(i==1){//这段代码就是不带头结点需要多写的代码逻辑
        LNode *s = (LNode *)malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;//将头指针指向新的结点
        return true;
    }
    LNode *p;	//指针p指向当前扫描到的结点
    int j = 1;	//当前p指向的是第几个结点
	p = L;		//p指向的是第一个结点（注意：不是头结点）
	while(p!=NULL && j<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;
	return true;
}

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

总结：不带头结点写代码更不方便，推荐使用带头结点

3.指定结点的后插操作

typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

//在第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;
        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;//插入成功
    //以上注释掉的内容可以用下面一句代码完成
    return InsertNextNode(p,e);
}

//后插操作：在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;
}

4.指定节点的前插操作

/*这里用到的思想是：虽然无法得知指定节点p的前驱，但是可以申请一片连续的空间s,将p中存放的元素放入到s中，然后将要插入的元素e放到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的next指向p的next所指向的后继结点
    p->next = s;		//将p的后继节点改为s
    s->data = p->data;	//将p结点中存放的元素复制到s中
    p->data = e;		//将要存放的数据元素e存放到p结点中
    return true;		//前插成功
    //此方法实现的操作时间复杂度为 O(1)
}

王道书本内的代码：

bool InsertPriorNode(LNode *p,LNode *s){
    if(p==NULL || s==NULL)
        return false;
    s->next = p->next;		//将s结点的后继结点指向p的后继节点
    p->next = s;			//将s连接到p之后
    ElemType temp = p->data;//将结点p的数据内容存入到一个中间变量temp中（交换数据域部分）
    p->data = s->data;		//将s中存放的要扦插的数据元素放入到s的前驱节点p中
    s->data = temp;			//将原来存放在p中的数据元素存入到s节点中
    return true;			//成功实现数据的前插操作
}

删除

1.按位序删除（带头结点）

ListDelete(&L,i,&e):删除操作，删除表L中的第i个位置上的元素，并用元素e返回删除元素的值

思路： 找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点，释放用free函数

bool ListDelete(LNode &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;
        j++;
    }
    if(p==NULL)	//i值不合法
        return false;
    if(p->next==NULL)//此时p结点(第i-1个结点)后面已无其他节点
        return false;
    LNode *q = p->next;	//令q指向被删除的结点
    e = q->data;		//用e返回被删除的元素e
    p->next = q->next;	//将*q结点从链中“断开”
    free(q);			//释放节点的存储空间
    return true;		//删除成功
}//此方法的最坏、平均时间复杂度为：O(n),最好时间复杂度为：O(1)

2.指定节点的删除

//删除指定节点
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;			//将*p结点从链中“断开”
    free(q);					//释放q结点的内存空间
    return true;
}

注意：此代码有一个局限性，当要删除的结点是最后一个结点，那么这个方法就会出现bug，p->data=p->next->data 就会出现错误，以为此时，p->next = NULL，这是找不到p->next->data的

bool Delete(LinkList L,LNode *p,ElemType &e){
    //在上面的参数表中传入头指针，循环查找p的前驱q，再对q操作，释放p，而不能钱买你的步骤不做，直接释放p
}//以下是前插操作的示例

小结：带头结点与不带头结点的代码都要会写