//删除递增有序链表中大于x小于y的元素 
void delLink(LinkList head, int x, int y){
    //找到x的前驱和y的后继 
    LNode *p = head->next;
    LNode *prex = NULL;
    while(p->data <= x) {
        prex = p;   //prex指向第一个<=x的位置 
        p = p->next;
    }
    while(p->data < y) {
        LNode *q = p;
        p = p->next;
        free(q);
    }
    prex->next = p;   //p指向第一个>=y的位置 
}

void DeleNode(LinkList *L, int x, int y){

    if(L -> next == NULL) return ERROR;

    LinkList *q = L -> next;

    LinkList *p = L;

    while(q->next){

        if(q-> data > x && q-> data < y){

            p-> next = q-> next;

            free(q);

            q = p -> next;

        }

        else{

            p = q;

            q = q-> next;

        }

    }

    return L;  

}

LNode* delete(LNode* head, ElemType x, ElemType y){
    auto p = head->next, pre = head;
    LNode* pre_st, *ed, *t;
    
    while(p){
        if(p->data > x) pre_st = pre;
        if(p->data > y) ed = p;
        pre = p; p = p->next;
    }
    
    while(pre_st->next != ed){
        t = pre_st->next;
        pre_st->next = t->next;
        delete t;
    }
    
    return head;
}

void erase(Lnode *head, int x, int y)
{
	Lnode *p = head -> next;
	
	if(!p) return ;
	
	Lnode *q = head;
	while(p)
	{
		if(p -> data > x && p -> data < y)
		{
			if(p -> next == NULL)
				q -> next = NULL;
			else 
				q -> next = p -> next;
				
			free(p);
			p = q -> next;
		}
		else p = p -> next;
	}
 } 

遍历

1. void Delete_list(Lnode *head, ElemType x, ElemType y) {
2. Lnode *p, *q;
3. if (!head) return ERROR;
4. p = head; q = p;
5. while(!p) {
6. if ((p->data>x) && (p->data<y)) {
7. if(p==head) {
8. head=p->next;
9. free(p);
10. p=head;
11. q=p;
12. }
13. else {
14. q->next=p->next;
15. free(p);
16. p=q->next;
17. }
18. }
19. else {
20. q=p;
21. p=p->next;
22. }
23.     }
24. }

link *delete(link *head, int x, int y) {

    link *temp = head;

    // 处理头节点

    while (temp != NULL && temp->data > x && temp->data < y) {

        link *to_delete = temp;

        temp = temp->next;

        free(to_delete);

    }

    link *current = temp;

    if (current == NULL) return NULL;

    // 处理非头节点

    while (current->next != NULL) {

        if (current->next->data > x && current->next->data < y) {

            link *to_delete = current->next;

            current->next = current->next->next;

            free(to_delete);

        } else {

            current = current->next;

        }

    }

    return temp;

}

typedef struct LNode{

    int data;

    struct LNode *next;

}LNode,*LinkList;

void delete(LinkList &L，int x , int y){

    //带头节点

    LNode *pre=L,*p=pre->next;

    while(p!=NULL){

        if(p->data<y&&p->data>x){

            pre->next=p->next;

            free(p);

            p=pre->next;

        }

        else{

            pre=p;

            p=p->next;

        }

    }

}

遍历；

free

void delet(LinkLinst L,ElementType x,ElementType y){
    Lnode* p=L->next;
    Lnode* pre=L;
    Lnode* q;
    while(p!=NULL){
        if(p->data>x&&p->data<y){
            pre->next=p-next;
            q=p;
            p=p-next;
            free(q);
        }
        else{
            p=p->next;
            pre=p;
        }
    } 
    return ;
}

jjk

void Delete_list(Lnode* &head, ElemType x, ElemType y) {
    Lnode* p;
    Lnode* q;

    if (!head) return;  // 如果链表为空，则直接返回

    p = head;
    q = nullptr;

    while (p) {
        if (p->data > x && p->data < y) {
            if (p == head) {  // 如果要删除的节点是头节点
                head = p->next;
                delete p;  // 使用 delete 替代 free
                p = head;
            } else {
                q->next = p->next;
                delete p;  // 使用 delete 替代 free
                p = q->next;
            }
        } else {
            q = p;
            p = p->next;
        }
    }
}

typedef struct LNode{

    int data;

    struct LNode *next;

}LNode,*LinkList;

void delete(LinkList &L，int x , int y){

    //带头节点

    LNode *pre=L,*p=pre->next;

    while(p!=NULL){

        if(p->data<y&&p->data>x){

            pre->next=p;

            free(p);

            p=pre->next;

        }

        else{

            pre=p;

            p=p->next;

        }

    }

}

typedef struct LinkNode{
	int data;
	struct *next;
}LinkNode;

void Delete_From_x_To_y(LinkNode *l, int x, int y){
    int count = 0; //统计删除结点的个数
	if(x > y)	return;
	LinkNode *p,*q;
	p = l;
	while(p->next->data < x)
		p = p->next;//找到小于等于x的最大结点
	q = p;
	while(q->data < y){
		q = q->next;
        count++;
}//找到大于等于y的最小结点
	LinkNode *n; //用于释放节点空间
	n = p->next;
	p->next = q;//删除[x,y]的元素
    for(int i = 0; i < count; i++)
    {LinkNode *s = n; n = n->next; free(s);}
	
}

struct Lnode{
	int data;
	Lnode * next;
}; 
//带头结点 
void del(Lnode * l,int x , int y){
	Lnode *p =l;
	if(p)   return ;
	while(p->next!=NULL){
		int t = p->next->data;
		if(t > x && t < y){
			Lnode * q = p->next;
			p->next=q->next;
			free(q); 
		}
		p=p->next;
	}
}

void deleteRange(Node **head, int x, int y) {
    Node *current = *head;
    Node *prev = NULL;

    while (current != NULL) {
        // 如果当前节点的值大于x且小于y
        if (current->data > x && current->data < y) {
            // 需要删除当前节点
            if (prev == NULL) {
                // 如果当前节点是头节点
                *head = current->next;
            } else {
                // 如果当前节点不是头节点
                prev->next = current->next;
            }
            Node *temp = current;
            current = current->next;
            free(temp); // 释放当前节点的内存空间
        } else {
            // 如果当前节点不需要删除，移动到下一个节点
            prev = current;
            current = current->next;
        }
    }
}

typedef struct {
    int data;
    struct LNode *next;
}LNode;
void Test(LNode *head,int x,int y){
    LNode *pre,*p;
    if(head->next!=NULL){
        pre=head;
        p=head->next;
        while (p->data<x){
            pre=p;
            p=p->next;
        }
        if(p->data>y){
            return;
        } else{
            while (p->data<=y){
                pre->next=p->next;
                free(p);
                p=pre->next;
            }
        }
    }
}

void DelElems(LinkList* head,int x,,int y)

{

if(y<x) return;

LinkList *p=head;LinkList *q;

while(p->next!=NULL){

if（p->next->data>x&&p->next->data<y）

q=p->next;

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

free(q);

p=p->next;

}

//

}

void filter(Lnode* L,int min,int max)

{

    Lnode* cur=L;

     while(cur->next->data!=Null)

{

  if(cur->next->data>x && cur->next->data<y)

{

   delete(cur,cur-next);

}

cur=cur->next;

}

}

void delete(Lnode* prenode ,Lnode *delnode)

{

Lnode* cur=delnode;

prenode->next=curnode->next;

free(delnode);

}

void Delete_list(Lnode *head, ElemType x, ElemType y) {

Lnode *p, *q;

if (!head) return ERROR;

p = head; q = p;

while(!p) {

    if ((p->data>x) && (p->data<y)) {

        if(p==head) {

            head=p->next;

            free(p);

            p=head;

            q=p;

        }

        else {

            q->next=p->next;

            free(p);

            p=q->next;

        }

    }

    else {

        q=p;

        p=p->next;

    }

}

boolean deleteLNode(LinkList *L,int x,int y){

LinkNode* prior=L->next;

if(!L->next){

return false;

}

while(prior&&prior->date<y&&prior->date>x){

L->next=prior->next;

piror=piror->next;

}

if(!L->next){

return true;

}

LinkNode* q=prior->next;

while(prior&&q){

if(q->date<y&&q->date>x){

prior->next=q->next;

}else{

prior=prior->next;

q=q->next;

}

}

}

p = L->next;

while(p->next!=NULL){

    if(p->next->data >x && p->next->data < y){

        node * d = p->next;

        p->next = d->next;

        delete *p;

     }

#include <stdio.h>

#include <stdlib.h>

#include <malloc.h>

typedef struct List

{

    int data;

    struct List *next;  

}List;

List* creat(int n)

{

    List* head = (List*)malloc(sizeof(List));

    head->next=NULL;

    List *p;

    p=head;

    for(int i=0;i<n;i++)

    {

        List* q = (List*)malloc(sizeof(List));

        scanf("%d",&q->data);

        q->next=NULL;

        p->next=q;

        p=q;

    }

    return head;

}

void print(List* head)

{

    List *p;

    p=head->next;

    while (p)

    {

        printf("%d ",p->data);

        p=p->next;

    }

}

void delete(List* head,int x,int y)

{

    List *p,*q;

    q=head;

    p=head->next;

    while (p)

    {

        if(p->data>x&&p->data<y)

        {

            q->next=p->next;

            free(p);

            p=q->next;

        }

        else

        {

            p=p->next;

            q=q->next;

        }

    }

}

int main ( )

{

    int n,x,y;

    printf("请输入单链表的长度：\n");

    scanf("%d",&n);

    printf("请输入表中各元素：\n");

    List* L=creat(n);

    printf("请输入x,y：\n");

    scanf("%d %d",&x,&y);

    printf("结果：\n");

    delete(L,x,y);

    print(L);

    return 0;

}

#include<stdio.h>
#include<stdlib.h>
#define M (List)malloc(sizeof(Node))
typedef struct Node{
    int data;
    Node* next;
}Node,*List;

List create(int n){
    List head=NULL,tail=NULL;
    for(int i=0;i<n+10;i++){
        List p=M;
        p->data=i;
        if(head==NULL) head=tail=p;
        else{
            tail->next=p;
            tail=p;
        }
    }
    tail->next=NULL;
    return head;
} 
void print(List head){
    while(head){
        printf("%d ",head->data);
        head=head->next;
    }
    printf("\n");
}
void Delete(List head,int x,int y){
    while(head->data>x&&head->data<y){
        head->data=head->next->data;
        List q=head->next;
        head->next=q->next;
        free(q);
        q=NULL;
    }
    List front=head,tail=head->next;
    while(tail){
        if(tail->data>x&&tail->data<y){
            front->next=tail->next;
            free(tail);
            tail=front->next;
        }else{
        front=tail;
        tail=tail->next;
    }
    }
} 

int main(){
    List head=create(0);
    int x,y;
    scanf("%d %d",&x,&y);
    print(head);
    Delete(head,x,y);
    
    print(head);
    return 0;
}

void deletespan(List *head, Ele x, Ele y)
{
    int n = length(head);
    List *p = head, *a, *b;

    for (int i = 0; i < n; i++)
    {
        if (p->next->data > x && p->next->data < y)
        {
            *a = p->next;
            p->next = p->next->next;
            free(a);
        }
        else
        {
            p = p->next;
        }
    }
}