C语言练习-day20

最新推荐文章于 2024-11-11 09:41:37 发布

Xiao__fly

最新推荐文章于 2024-11-11 09:41:37 发布

阅读量756

点赞数

文章标签： c语言数据结构链表

本文链接：https://blog.csdn.net/Xiao__fly/article/details/123598000

版权

题目：设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点。

输入：不带头结点的链表个元素的值，类型为int，以9999结束。

输出：删除所有值为x的结点后输出单链表。

优化目标：无。

算法思想：递归的终止条件：若L为空表，不做任何事；递归的主体：若L->data == x，删除L结点，然后调用该函数（L指向下一个元素），其他情况就调用该函数（L指向下一个元素）。

#include<stdio.h>
#include<stdlib.h>

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

void del_x(LinkList &L,int x){
    if(L == NULL){
        return;
    }
    if(L->data == x){
        LNode *p = L;
        L = L->next;
        free(p);
        del_x(L,x);
    }
    else{
        del_x(L->next,x);
    }
}

//创建链表
void creatList(LinkList &L){
    LNode *s,*r;
    int x;
    printf("请输入链表元素值（以9999结束）：");
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    r = L;
    scanf("%d",&x);
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        s->next = NULL;
        r = s;
        scanf("%d",&x);
    }
}

//输出链表
void PrintList(LinkList L){
    LNode *p = L->next;
    printf("链表元素有：");
    while(p!=NULL){
        printf("%d   ",p->data);
        p = p->next;
    }
    printf("\n");
}



int main() {
	LinkList L;
	creatList(L);
	PrintList(L);
	printf("请输入想要删除的值：");
	int x;
	scanf("%d",&x);
	del_x(L,x);
	PrintList(L);
	
	
	return 0;
}

题目：在带头结点的单链表L中，删除所有值为x的结点，并释放其空间，假设值为x的结点不唯一，试编写算法以实现上述操作。

输入：带头结点的链表个元素的值，类型为int，以9999结束。

输出：删除所有值为x的结点后输出单链表。

优化目标：无。

算法思想：从头到尾扫描单链表，pre指向扫描结点的前一个结点，当扫描的元素的值等于x的话，就删除扫描的结点。

#include<stdio.h>
#include<stdlib.h>

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



void del_X(LinkList &L,int x){
    LNode *p = L->next,*pre = L,*s;
    while(p!=NULL){
        if(p->data == x){
            s = p;
            p = p->next;
            pre->next = p;
            free(s);
        }
        else{
        	pre = p;
            p = p->next;
        }
    }
}



//创建链表
void creatList(LinkList &L){
    LNode *s,*r;
    int x;
    printf("请输入链表元素值（以9999结束）：");
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    r = L;
    scanf("%d",&x);
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        s->next = NULL;
        r = s;
        scanf("%d",&x);
    }
}

//输出链表
void PrintList(LinkList L){
    LNode *p = L->next;
    printf("链表元素有：");
    while(p!=NULL){
        printf("%d   ",p->data);
        p = p->next;
    }
    printf("\n");
}



int main() {
	LinkList L;
	creatList(L);
	PrintList(L);
	printf("请输入想要删除的值：");
	int x;
	scanf("%d",&x);
	del_X(L,x);
	PrintList(L);
	
	
	return 0;
}

题目：设L为带头结点的单链表，编写算法实现从头到尾反向输出每个结点的值。

输入：带头结点的链表个元素的值，类型为int，以9999结束。

输出：从头反向输出单链表。

优化目标：无。

算法思想：每当访问一个结点时，先递归输出它后面的结点，再输出该结点自身，这样链表就可以反向输出了。

#include<stdio.h>
#include<stdlib.h>

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

//反向输出链表
void Print_R(LinkList L){
    if(L->next != NULL){
        Print_R(L->next);
    }
    if(L != NULL){
        printf("%d  ",L->data);
    }
}
void Print_IgoreHead(LinkList L){
    if(L->next!=NULL){
        Print_R(L->next);
    }
}


//创建链表
void creatList(LinkList &L){
	L = NULL;
    LNode *s,*r;
    int x;
    printf("请输入链表元素值（以9999结束）：");
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    r = L;
    scanf("%d",&x);
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        s->next = NULL;
        r = s;
        scanf("%d",&x);
    }
}

//输出链表
void PrintList(LinkList L){
    LNode *p = L->next;
    printf("链表元素有：");
    while(p!=NULL){
        printf("%d   ",p->data);
        p = p->next;
    }
    printf("\n");
}



int main() {
	LinkList L;
	creatList(L);
	PrintList(L);
	Print_IgoreHead(L);
	
	
	return 0;
}

题目：试编写在带头结点的单链表L中删除一个最小值结点的高效算法（假设最小值结点是唯一的）。

输入：带头结点的链表个元素的值，类型为int，以9999结束。

输出：删除最小值的结点后输出单链表。

优化目标：无。

算法思想：用p从头到尾扫描单链表，pre指向p结点的前驱，用min保存最小值结点，minpre保存最小值结点的前驱。一边扫描一边比较，若p->data小于min->data时，就将p和pre分别赋给min，minpre。最后将min的结点删除即可。

#include<stdio.h>
#include<stdlib.h>

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


//删除最小值元素
void del_min(LinkList &L){
    LNode *pre = L,*p = pre->next;
    LNode *minpre = pre,*min = p;
    while(p!=NULL){
        if(min->data>p->data){
            minpre = pre;
            min = p;
        }
        pre = p;
        p = p->next;
    }
    minpre->next = min->next;
    free(min);
}


//创建链表
void creatList(LinkList &L){
    LNode *s,*r;
    int x;
    printf("请输入链表元素值（以9999结束）：");
    L = (LinkList)malloc(sizeof(LNode));
    L->next = NULL;
    r = L;
    scanf("%d",&x);
    while(x!=9999){
        s = (LNode *)malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        s->next = NULL;
        r = s;
        scanf("%d",&x);
    }
}

//输出链表
void PrintList(LinkList L){
    LNode *p = L->next;
    printf("链表元素有：");
    while(p!=NULL){
        printf("%d   ",p->data);
        p = p->next;
    }
    printf("\n");
}



int main() {
	LinkList L;
	creatList(L);
	PrintList(L);
	del_min(L);
	PrintList(L);
	
	return 0;
}

今天做了几道单链表的题，单链表的操作相对于顺序表的操作更复杂一点，而且里面的思想更加多样。今天最难我觉得就是反向输出单链表，按常规思考可能要创一个新的单链表，但是别人利用了递归调用，还是很不错的。明天还要继续做单链表的题。