void delete(List* head,int a,int b)

{List* p,q;

q=head;

p=q->next;

while(p!=head)

{if(p->data>a&&p->data<b)

{q->next=p->next;

free(p);

p=q->next;}

else

{p=p->next;

q=q->next;}

}}

void delete(List* head,int a,int b)

{List *p,*q;

q=head;

p=head->next;

while(p!=head)

{if(p->data>a&&p->data<b)

{q->next=p->next;

free(p);

p=q->next;

}

else

{p=p->next;

q=q->next;}

include <stdio.h>

typedef struct node{

     int data;

     struct node *next;

}Lnode;

int text1(Lnode *L){

     Lnode *s=L;

     if(s->next==L) return -1;

     while(s->next!=L){

          if(s->data>a&&s->data<b){

              Lnode *s2=s->next;

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

              free(s2);

          }

          s=s->next;

     }

     return 0;

}

int main(){

     Lnode *L;

     int a=text1(L);

}

int Nnuo(linklist l, int a, int b) {
    Lnode* q, * p, * r, * t;
    q = p = l;
    r = l->next;
    if (r == NULL)    return 0;

    while (r->data < a&&r->next!=NULL) {
        t = r;
        r = r->next;
        free(t);
    }
    q = r;
    while (r->data < b%%r->data>a && r->next != NULL) {
        t = r;
        r = r->next;
        free(t);
    }
    p = r;
    q->next = p;
    free(q);
    free(p);
    return 0;

}

void del(List &L,int a,int b){
    LNode *q=L;
    LNode*p=L->next;
    while(p!=L){
        if(p->data>a&&p->data<b){
            q->next=p->next;
            delete p;
            p=q->next;
        }else{
            q=p;
            p=p->next;
        }
    }
    
    
}

1. void delete(List* head, int a, int b) {
2. List *p, *q;
3. q = head;
4. p = head->next;
5. while (p != head) {
6. if(p->data > a && p->data < b) {
7. q->next = p->next;
8. free(p);
9. p = q->next;
10. }
11. else {
12. p = p->next;
13. q = q->next;
14. }
15. }
16. }

// 定义链表节点结构体
typedef struct ListNode {
    int data;
    struct ListNode *next;
} ListNode;

// 初始化带头结点的循环链表
ListNode* initList() {
    ListNode* head = (ListNode*)malloc(sizeof(ListNode));
    head->next = head;
    return head;
}

// 在循环链表中插入节点，保持有序
void insertNode(ListNode* head, int val) {
    ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
    newNode->data = val;
    ListNode* p = head;
    while (p->next!= head && p->next->data < val) {
        p = p->next;
    }
    newNode->next = p->next;
    p->next = newNode;
}

// 删除链表L中元素值大于a且小于b的所有结点的算法函数
void deleteNodes(ListNode* head, int a, int b) {
    ListNode* prev = head;
    ListNode* curr = head->next;
    while (curr!= head) {
        if (curr->data > a && curr->data < b) {
            prev->next = curr->next;
            ListNode* temp = curr;
            curr = curr->next;
            free(temp);
        } else {
            prev = curr;
            curr = curr->next;
        }
    }
}

void delLink(LinkList head, int a, int b){
    //找到a的前驱和b的后继 
    LNode *p = head->next;
    LNode *prex = NULL;
    while(p != head && p->data <= a) {
        prex = p;   //prex指向第一个<=a的位置 
        p = p->next;
    }
    while(p != head && p->data < b) {
        LNode *q = p;
        p = p->next;
        free(q);
    }
    prex->next = p;   //p指向第一个>=b的位置 
}

find a, b 两个指针

a->next = b;

void DeleNode(LinkList *L, int a, int b){

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

    LinkList *p = L -> next;

    LinkList *q = L;

    while(p -> next != L){

        if(p -> data < a){

            q = p;

            p = p -> next;

        }

        else if(p -> data > a && p -> data < b){

            q -> next = p -> next;

            p = q -> next;

        }

        else if(p -> data > b) break;

    }

    return L;

}

void delete(List* head, int a, int b) {
    List *p, *q;
    q = head;
    p = head->next;
    while (p != head) {
        if(p->data > a && p->data < b) {
            q->next = p->next;
            free(p);
            p = q->next;
        }
        else {
            p = p->next;
            q = q->next;
        }
    }
}

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

1. void delete(List* head, int a, int b) {
2. List *p, *q;
3. q = head;
4. p = head->next;
5. while (p != head) {
6. if(p->data > a && p->data < b) {
7. q->next = p->next;
8. free(p);
9. p = q->next;
10. }
11. else {
12. p = p->next;
13. q = q->next;
14. }
15. }
16. }

void del(LinkList L,int a,int b){
    LNode* q,p=L;
    while(p->next!=NULL&&p!=NULL){
        q=p->next;
        if(q->data<b&&q->data>a){
            p->next=q->next;
            delete q;
        }
        p=p->next;
    }
    return ;
} 

#include<stdio.h>

typedef struct node {

    int data;

    struct node *next;

} link;

link *creat(int a[],int size) {

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

    head->next=NULL;

    head->data=a[0];

    link *p=head;

    for(int i=1; i<size; i++) {

        link *temp=(link*)malloc(sizeof(link));

        temp->data=a[i];

        temp->next=NULL;

        p->next=temp;

        p=p->next;

    }

    return head;

}

void maopao(link *head,int size) {

    int n;

    for(int i=0; i<size-1; i++) {

        link *p=head,*q=head->next;

        for(int j=0; j<size-i-1; j++) {

            if(p->data>q->data) {

                n=p->data;

                p->data=q->data;

                q->data=n;

            }

            p=p->next;

            q=q->next;

        }

    }

}

void printlist(link *p) {

    link *temp=p;

    while(temp!=NULL) {

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

        if(temp->next!=NULL)

            printf("->");

        temp=temp->next;

    }

    putchar(10);

}

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

    link *temp=head;

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

        link *p=temp;

        temp=temp->next;

        free(p);

    }

    link *qemp=temp;

    while(qemp->next!=NULL){

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

            link *p=qemp;

            qemp->next=qemp->next->next;

            free(p);

        }

        else

        qemp=qemp->next;

    }

    return temp;

}

//循环链表

link *revers(link *head){

    link *temp=head;

    while(temp->next!=NULL){

        temp=temp->next;

    }

    temp->next=head;

    return head;

}

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

    link *temp=head;

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

        link *p=temp;

        temp=temp->next;

        free(p);

    }

    link *qemp=temp;

    while(qemp->next!=head){

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

            link *p=qemp->next;

            qemp->next=qemp->next->next;

            free(p);

        }

        else

        qemp=qemp->next;

    }

    return temp;

}

int main()

{

    int a[]= {5,8,2,9,3,7,1};

    int size=sizeof(a)/sizeof(a[0]);

    link *head=creat(a,size);

    printlist(head);

    maopao(head,size);

    printlist(head);

    /*printf("删除大于5小于9的元素:\n");

    head=delete(head,5,9);

    printlist(head);*/

    head=revers(head);

    printf("删除大于5小于9的元素:\n")

    return 0;

}

遍历找到位置 依次跳过

void delete(List* head, int a, int b) {
    List *p, *q;
    q = head;
    p = head->next;
    while (p != head) {
        if(p->data > a && p->data < b) {
            q->next = p->next;
            free(p);
            p = q->next;
        }
        else {
            p = p->next;
            q = q->next;
        }
    }
}

j h h

void delete(List* head, int a, int b) {
    List* p, * q;
    q = head;
    p = head->next;
    while (p != head) {
        if (p->data > a && p->data < b) {
            q->next = p->next;
            free(p);
            p = q->next;
        }
        else {
            p = p->next;
            q = q->next;
        }
    }
}

和上题类似，只不过循环的条件改为p!=L

1. void delete(List* head, int a, int b) {
2. List *p, *q;
3. q = head;
4. p = head->next;
5. while (p != head) {
6. if(p->data > a && p->data < b) {
7. q->next = p->next;
8. free(p);
9. p = q->next;
10. }
11. else {
12. p = p->next;
13. q = q->next;
14. }
15. }
16. }

    void delete(List* head, int a, int b) {
        List *p, *q;
        q = head;
        p = head->next;
        while (p != head) {
            if(p->data > a && p->data < b) {
                q->next = p->next;
                free(p);
                p = q->next;
            }
            else {
                p = p->next;
                q = q->next;
            }
        }
    }

     

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 DelElems(LinkList  head,int a,int b)

{

LinkList* p=head;

LinkList *del;

while(p->next!=NULL);

if(p->next>a||p->next<b) 

del=p->next;

p->next=del->next;

free(del);

p=p->next;

}

}

void delete(List* head,int a, int b){

 List *p,*q;

q=head;

p=head->next;

while(p!=head){

if(p->data>a&&p->data<b){

q->next=p->next;free(p);p=q->next;}

else {p=p->next;q=q->next;}

}

}

void delete(List* head, int a, int b) {

    List *p, *q;

    q = head;

    p = head->next;

    while (p != head) {

        if(p->data > a && p->data < b) {

            q->next = p->next;

            free(p);

            p = q->next;

        }

        else {

            p = p->next;

            q = q->next;

        }

    }

}

#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=head;

    List *p;

    p=head;

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

    {

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

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

        q->next=head;

        p->next=q;

        p=q;

    }

    return head;

}

void print(List* head)

{

    List *p;

    p=head->next;

    while (p!=head)

    {

        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!=head)

    {

        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;

}

void Delete_list(Lnode *head, ElemType a, ElemType b) {

    Lnode *p, *q;

    if(!head->next) return ERROR;

    p=head->next; q=p; while(p->next!=head)

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

    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; }

    }

    }

asdasdasdasda