考研C语言第十一章

已于 2024-09-12 22:14:13 修改
阅读量35 收藏
点赞数
文章标签： 考研 c语言 开发语言
于 2023-07-25 21:41:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/satellite_s/article/details/131925915
版权

单链表的新建查找

11.3头插法新建链表实战

每一个内存在空间上是不连续的
在这里插入图片描述
链表的头插法（新增加的元素在链表头部，最早增加的元素在链表尾部）

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef  int ElemType;

typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;
//LNode*和LinkList这两种表达式等价的
//只有第一个插入的元素老老实实连接头结点，剩下的插入新的数据都可以用循环实现
void list_head_insert(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));//为头指针申请空间，有了头指针就指向头结点了
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s;
//    s=(LinkList)malloc(sizeof(LNode));
//    s->data=x;
//    //由于第一个插入的元素是头插法，所以它一定是最后一个元素，最后一个元素的指针域是需要设置为null的
//    //！！C语言里面NULL必须大写！！！
//    s->next=NULL;
//    L->next=s;//头结点的next，就指向了第一个节点
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;//让新节点指针域指向原本链表的第一个节点
        L->next=s;//头结点的next指向新结点
        scanf("%d",&x);
    }
}

void print_list(LinkList L){
    L=L->next;
    while(L!=NULL)
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//头插法：每次插入新的元素从头部插入
int main(){
    LinkList L;//L是链表头指针，是结构体指针类型
    list_head_insert(L);
    print_list(L);
    return 0;
}

还是记住全部都在循环里面的代码比较好，注释掉的代码会导致第一个元素重复插入的bug

11.4尾插法新建链表

在这里插入图片描述
尾插法会定义一个指针变量始终指向链表的尾部，方便插入新的元素，每次r=r.next就行

尾插法方法代码

//尾插法新建链表
void list_tail_insert(LinkList &L){
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//连续定义了两个指针，s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾部节点的next指针
        r=s;//r要指向新的尾部,保证循环顺利进行
        scanf("%d",&x);
    }
    r->next=NULL;//让尾节点的next为NULL
}

main调用代码：

int main(){
    LinkList L;//L是链表头指针，是结构体指针类型
//    list_head_insert(L);
    list_tail_insert(L);
    print_list(L);
    return 0;
}

11.5按位置查找及按值查找实战

按位置查找（用户输入要查询的位置，找到这个位置放的数）

//按位置查找
LinkList GetElem(LNode* L,int searchpos){
    int i=0;
    //意思是L不是NULL而且还没到查找的位置
    if(searchpos<0)
    {
        return NULL;
    }
    while(L&&i<searchpos)
    {
        L=L->next;
        i++;
    }
    return L;
}

main方法里面

    //按位置查找
    search=GetElem(L,2);
    
    if(search!=NULL)
    {
        printf("success in searching by serial number\n");
        printf("%d\n",search->data);
    }

按照值查找（用户输入一个数）查询这个数在不在链表里面

//按值查找
LinkList GetElemzhi(LinkList L,ElemType searchzhi){
    while(L)
    {
        if(L->data==searchzhi)
        {
            return L;
        }
        L=L->next;
    }
    return NULL;
}

main方法

    //按值查找
    searchzhi=GetElemzhi(L,6);
    if(searchzhi!=NULL)
    {
        printf("success find the true num\n");
        printf("%d\n",searchzhi->data);
    }

本节课总代码：

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef  int ElemType;

typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*和LinkList这两种表达式等价的
//只有第一个插入的元素老老实实连接头结点，剩下的插入新的数据都可以用循环实现
void list_head_insert(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));//为头指针申请空间，有了头指针就指向头结点了
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s;
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;//让新节点指针域指向原本链表的第一个节点
        L->next=s;//头结点的next指向新结点
        scanf("%d",&x);
    }
}
//尾插法新建链表
void list_tail_insert(LinkList &L){
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//连续定义了两个指针，s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾部节点的next指针
        r=s;//r要指向新的尾部,保证循环顺利进行
        scanf("%d",&x);
    }
    r->next=NULL;//让尾节点的next为NULL
}

void print_list(LinkList L){
    L=L->next;
    while(L!=NULL)
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}
//按位置查找
LinkList GetElem(LNode* L,int searchpos){
    int i=0;
    //意思是L不是NULL而且还没到查找的位置
    if(searchpos<0)
    {
        return NULL;
    }
    while(L&&i<searchpos)
    {
        L=L->next;
        i++;
    }
    return L;
}
//按值查找
LinkList GetElemzhi(LinkList L,ElemType searchzhi){
    while(L)
    {
        if(L->data==searchzhi)
        {
            return L;
        }
        L=L->next;
    }
    return NULL;
}
//头插法：每次插入新的元素从头部插入
int main(){
    LinkList L,search,searchzhi;//L是链表头指针，是结构体指针类型
//    list_head_insert(L);
    list_tail_insert(L);
    print_list(L);
    //按位置查找
    search=GetElem(L,2);

    if(search!=NULL)
    {
        printf("success in searching by serial number\n");
        printf("%d\n",search->data);
    }
    //按值查找
    searchzhi=GetElemzhi(L,6);
    if(searchzhi!=NULL)
    {
        printf("success find the true num\n");
        printf("%d\n",searchzhi->data);
    }
    return 0;
}

11.6往第i个位置插入元素

方法代码：

//往第i个位置插入一个数字，实现逻辑：首先利用按位置查找，找到位置，然后找到位置的前一个，从而改变next
bool ListFrontInsert(LinkList L,int i,ElemType InsertVal)
{
    LinkList p= GetElem(L,i-1);
    if(p==NULL)
    {
        return false;
    }
    LinkList q;
    q=(LinkList) malloc(sizeof (LNode));
    q->data=InsertVal;
    q->next=p->next;
    p->next=q;
    return true;
}

main方法调用代码：

int main(){
    LinkList L,search,searchzhi;//L是链表头指针，是结构体指针类型
//    list_head_insert(L);
    list_tail_insert(L);
    bool ret;
    ret=ListFrontInsert(L,2,99);
    print_list(L);

    return 0;
}

总代码备注：

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 50
typedef  int ElemType;

typedef struct LNode{
    ElemType data;//数据域
    struct LNode *next;//指针域
}LNode,*LinkList;

//LNode*和LinkList这两种表达式等价的

//只有第一个插入的元素老老实实连接头结点，剩下的插入新的数据都可以用循环实现
void list_head_insert(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));//为头指针申请空间，有了头指针就指向头结点了
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s;
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;//让新节点指针域指向原本链表的第一个节点
        L->next=s;//头结点的next指向新结点
        scanf("%d",&x);
    }
}
//尾插法新建链表
void list_tail_insert(LinkList &L){
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s,*r=L;//连续定义了两个指针，s是用来指向申请的新结点，r始终指向链表尾部
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));//为新结点申请空间
        s->data=x;
        r->next=s;//新结点给尾部节点的next指针
        r=s;//r要指向新的尾部,保证循环顺利进行
        scanf("%d",&x);
    }
    r->next=NULL;//让尾节点的next为NULL
}

void print_list(LinkList L){
    L=L->next;
    while(L!=NULL)
    {
        printf("%3d",L->data);
        L=L->next;
    }
    printf("\n");
}

//按位置查找
LinkList GetElem(LNode* L,int searchpos){
    int i=0;
    //意思是L不是NULL而且还没到查找的位置
    if(searchpos<0)
    {
        return NULL;
    }
    while(L&&i<searchpos)
    {
        L=L->next;
        i++;
    }
    return L;
}

//按值查找
LinkList GetElemzhi(LinkList L,ElemType searchzhi){
    while(L)
    {
        if(L->data==searchzhi)
        {
            return L;
        }
        L=L->next;
    }
    return NULL;
}

//往第i个位置插入一个数字，实现逻辑：首先利用按位置查找，找到位置，然后找到位置的前一个，从而改变next
bool ListFrontInsert(LinkList L,int i,ElemType InsertVal)
{
    LinkList p= GetElem(L,i-1);
    if(p==NULL)
    {
        return false;
    }
    LinkList q;
    q=(LinkList) malloc(sizeof (LNode));
    q->data=InsertVal;
    q->next=p->next;
    p->next=q;
    return true;
}

int main(){
    LinkList L,search,searchzhi;//L是链表头指针，是结构体指针类型
//    list_head_insert(L);
    list_tail_insert(L);
    bool ret;
    ret=ListFrontInsert(L,2,99);
    print_list(L);

    return 0;
}

OJ作业

在这里插入图片描述
在这里插入图片描述

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

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

//头插法
void list_head_insert(LinkList &L)
{
    L=(LinkList) malloc(sizeof(LNode));
    L->next=NULL;
    ElemType  x;
    scanf("%d",&x);
    LNode *s;
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        scanf("%d",&x);
    }
}

//尾插法
void list_tail_insert(LinkList &L)
{
    L=(LinkList)malloc(sizeof(LNode));
    L->next=NULL;
    ElemType x;
    scanf("%d",&x);
    LNode *s;
    LNode *r=L;
    while(x!=9999)
    {
        s=(LinkList)malloc(sizeof(LNode));
        s->data=x;
        r->next=s;
        r=s;
        scanf("%d",&x);
    }
    r->next=NULL;
}

//打印的方法
void PrintList(LinkList L)
{
    L=L->next;
    while(L!=NULL)
    {
        printf("%d",L->data);//打印当前结点数据
        L=L->next;//指向下一个结点
        if(L!=NULL)
        {
            printf(" ");
        }
    }
    printf("\n");
}


int main(){
    LinkList L;
    list_head_insert(L);
    PrintList(L);
    list_tail_insert(L);
    PrintList(L);

}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值