day15

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量705 收藏 20
点赞数 22
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75400389/article/details/140558784
版权

一、链表的引入


1.1    总结顺序表的优缺点


1>    优点：能够直接通过下标进行定位元素，访问效率高，对元素进行查找和修改比较快
2>    不足：插入和删除元素需要移动大量的元素，效率较低
3>    缺点：存储数据元素有上限，当达到MAX后，就不能再添加元素了


1.2    链表的概念


1>    链式存储的线性表叫做链表
1、链式存储：表示数据元素的存储地址不一定连续
2、线性表：数据元素之间存在一对一的关系
2>    链表的原理图如下

3>    链表的基础概念
 

1、节点：节点是链表的基本单位，由数据域和指针域组成
2、数据域：存放数据元素的部分
3、指针域：存放下一个节点地址的部分
4、前驱节点：当前节点的上一个节点
5、后继节点：当前节点的下一个节点
6、头节点：虚设的一个节点，数据域不存放数据元素，可以存放链表的长度
7、头指针：指向第一个节点的指针称为头指针
8、第一个节点：实际存储数据元素的链表上的第一个节点
注意：头节点的指针域其实就是头指针，也可以单独定义一个指针，指向第一个节点
4>    链表的分类
 

1、单向链表：只能从头节点或第一个节点出发，单向访问其后继节点的链表称为单向链表
2、双向链表：从头部出发，既可以访问前驱节点，也可以访问后继节点
3、循环链表：首尾相接的链表称为循环链表


二、单向链表


只能从头节点或第一个节点出发，单向访问其后继节点的链表称为单向链表


2.1    节点结构体类型


1>    头节点和普通节点数据域可以合到一起，使用一格共用体表示
2>    指针域都是指向普通节点的地址
 

//定义数据类型
typedef int datatype;
 
//定义结点类型
typedef struct Node
{
    union
    {
        int len;    //头结点数据域
        datatype data;  //普通结点数据域
    };
 
    struct Node *next;   //指针域
};Node,*NodePtr
 
 
 


2.2    创建链表


1>    在堆区申请一格头节点的空间，就创建了一个链表
2>    需要对头节点的数据域初始化链表长度，指针域初始化NULL
 

//创建链表
NodePtr list_create()
{
    //只需要在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if(NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }
 
    //程序执行至此，说明头结点创建结束
    L->len = 0;    //表示链表长度为0
    L->next = NULL;      ///防止野指针
 
    printf("链表创建成功\n");
    return L;
}


 
2.3    申请节点封装数据


1>    需要将要封装的数据当做函数的参数进行传递
2>    同样在堆区申请节点，就传入的数据放入数据域
 

//申请结点封装数据函数
NodePtr apply_node(datatype e)
{
    //在堆区申请一个结点的大小
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("结点申请失败\n");
        return NULL;
    }
 
    //给结点内容赋值
    p->data = e;          //数据域赋值
    p->next = NULL;        //指针域
 
    return p;
}


 
2.4    链表判空


1>    只需要判断头节点的指针域中是否为空即可
 

//链表判空
int list_empty(NodePtr L)
{
    return L->next == NULL;
}
 


2.5    头插


1>    表示将新插入的节点放入第一个节点中
2>    插入数据时，不能先将前面节点与后面节点先断开。一定要从新节点出发，指向后面的节点，然后将前驱节点指向字节
 

//头插
int list_insert_head(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("链表不合法\n");
        return -1;
    }
 
    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }
 
    //头插逻辑
    p->next = L->next;
    L->next = p;
    
    
    //表的变化
    L->len ++;
    printf("头插成功\n");
    return 0;
}
 
 


2.6    链表遍历


需要使用一个遍历指针，将每一个节点进行遍历一遍，如果该指针指向的节点不为空，就访问其数据域，向后偏移
 

//链表遍历函数
int list_show(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }
    
    printf("链表中的元素分别是：");
    //遍历逻辑
    NodePtr q = L->next;   //定义遍历指针从第一个结点出发
    while(q != NULL)
    {
        //输出数据域
        printf("%d\t", q->data);
 
        q = q->next;    //指针向后偏移一个
    }
}
 
 


2.7    通过位置查找节点


1>    参数：链表、位置
2>    返回值：对应节点的地址
 

//通过位置查找结点
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }
 
    //查找逻辑
    //定义遍历指针从头结点出发
    NodePtr q = L;
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }
 
    return q;     //将找到的结点地址返回
}
 


2.8    任意位置插入元素


1>    参数：链表、位置、要插入的元素
2>    返回值：int
3>    注意：必须找到要插入位置的节点的前驱节点，将前驱节点当作头节点，进行头插操作
 

//任意位置插入
int list_insert_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || pos<1 || pos>L->len+1)
    {
        printf("插入失败\n");
        return -1;
    }
    
    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }
    
    //调用函数查找前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //插入逻辑
    p->next = q->next;
    q->next = p;
    
    //表的变化
    L->len++;
    printf("插入成功\n");
    return 0;
}


 
2.9    链表头删


1>    参数：链表
2>    返回值：int
3>    注意：需要将要删除的节点先标记一下，头节点的指针，指向第二个节点后，将标记的节点释放
 

//链表头删
int list_delete_head(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    
    //删除三部曲
    NodePtr p = L->next;    //标记
    L->next = p->next;  //L->next->next  孤立
    free(p);            //释放
    p = NULL;
 
    //表长变化
    L->len--;
 
    printf("头删成功\n");
    return 0;
}
 


2.10    任意位置删除函数


1>    参数：链表、要删除的位置
2>    返回值:int
3>    注意：需要找到要删除的节点的前驱节点，将其当作头节点，进行头删逻辑
Plain Text
自动换行

//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    
    //找到前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //删除逻辑
    NodePtr p = q->next;           //标记
    q->next = q->next->next;   //p->next 孤立
    free(p);                   //释放
    p = NULL;
 
    
    //表的变化
    L->len--;
    printf("删除成功\n");
    return 0;
}
 
 


2.11    按值查找返回位置


1>    参数：链表、要查找的值
2>    返回值：元素在链表中的位置
Plain Text
自动换行

//链表按值查找返回位置
int list_search_value(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("查找失败\n");
        return -1;
    }
    
    //查找逻辑
    //定义遍历指针从第一个结点出发
    NodePtr q = L->next;
    for(int index=1; index<=L->len; index++)
    {
        //判断当前结点的值是否为要找的数据
        if(q->data == e)
        {
            return index;
        }
 
        q = q->next;     //继续向后遍历
    }
 
    //程序执行至此，表示没找到
    printf("没找到\n");
    return -1;
}
 


2.12    按位置修改


1>    参数：链表、要修改的元素位置、要被更新的值
2>    返回值：int
3>    注意：先通过位置，找到对应的元素，更改该元素中的内容即可
Plain Text
自动换行

//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按位置查找逻辑
    NodePtr p = list_search_pos(L, pos);
    
    //修改逻辑
    p->data = e;
 
    printf("修改成功\n");
    return 0;
}
 


2.13    按值进行修改函数


1>    参数：链表、旧值、新值
2>    返回值：int
3>    思路：先通过旧值找到位置，通过位置进行修改
Plain Text
自动换行

//按值进行修改
int list_update_value(NodePtr L, datatype old_e, datatype new_e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按值查找位置
    int res = list_search_value(L, old_e);
    if(res == -1)
    {
        printf("没有要修改的值\n");
        return -1;
    }
    
    //按位置修改
    list_update_pos(L, res, new_e);
    
    printf("修改成功\n");
    return 0;
}
 


2.14    链表的反转


1>    参数：链表
2>    返回值：int
3>    注意：在该操作中，没有节点被删除，也没有节点被释放
 

//将链表进行翻转
void list_reverse(NodePtr L)
{
    //判断逻辑
    if(NULL==L || L->len<=1)
    {
        printf("翻转失败\n");
        return ;
    }
    
    //翻转逻辑
    NodePtr H = L->next;   //将链表元素进行托付
 
    L->next = NULL;        //自己白手起家
 
    NodePtr p = NULL;         //结点的搬运工
 
    while(H != NULL)
    {
        p = H;      //搬运第一个结点
        H = H->next;     //头指针后移
 
        //将p以头插的方式放入L中
        p->next = L->next;
        L->next = p;
    }
 
    printf("翻转成功\n");
    
}
 


2.15    链表的释放


1>    参数：链表
2>    返回值：无
3>    注意：需要先将所有的节点内存全部释放后，再将头节点释放
Plain Text
自动换行

//释放链表
void list_destroy(NodePtr L)
{
    //判断逻辑
    if(NULL == L)
    {
        return;
    }
 
    //将所有结点进行释放
    while(!list_empty(L))
    {
        //头删
        list_delete_head(L);
    }
 
    //释放头结点
    free(L);
    L = NULL;
 
    printf("释放成功\n");
}
 


2.16    代码总结


1>    linklist.h
Plain Text
自动换行

#ifndef LINKLIST_H
#define LINKLIST_H
#include<myhead.h>
 
//定义数据类型
typedef int datatype;
 
//定义结点类型
typedef struct Node
{
    union
    {
        int len;    //头结点数据域
        datatype data;  //普通结点数据域
    };
 
    struct Node *next;   //指针域
}Node, *NodePtr;
 
//创建链表
NodePtr list_create();
 
//申请结点封装数据函数
NodePtr apply_node(datatype e);
 
//链表判空
int list_empty(NodePtr L);
 
//头插
int list_insert_head(NodePtr L, datatype e);
 
//链表遍历函数
int list_show(NodePtr L);
 
//通过位置查找结点
NodePtr list_search_pos(NodePtr L, int pos);
 
//任意位置插入
int list_insert_pos(NodePtr L, int pos, datatype e);
 
//链表头删
int list_delete_head(NodePtr L);
 
//链表任意位置删除
int list_delete_pos(NodePtr L, int pos);
 
//链表按值查找返回位置
int list_search_value(NodePtr L, datatype e);
 
//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e);
 
//按值进行修改
int list_update_value(NodePtr L, datatype old_e, datatype new_e);
 
//将链表进行翻转
void list_reverse(NodePtr L);
 
//释放链表
void list_destroy(NodePtr L);
 
 
 
 
 
#endif
 
2>    linklist.c
Plain Text
自动换行

#include"linklist.h"
 
//创建链表
NodePtr list_create()
{
    //只需要在堆区申请一个头结点
    NodePtr L = (NodePtr)malloc(sizeof(Node));
    if(NULL == L)
    {
        printf("创建失败\n");
        return NULL;
    }
 
    //程序执行至此，说明头结点创建结束
    L->len = 0;    //表示链表长度为0
    L->next = NULL;      ///防止野指针
 
    printf("链表创建成功\n");
    return L;
}
 
 
 
//申请结点封装数据函数
NodePtr apply_node(datatype e)
{
    //在堆区申请一个结点的大小
    NodePtr p = (NodePtr)malloc(sizeof(Node));
    if(NULL == p)
    {
        printf("结点申请失败\n");
        return NULL;
    }
 
    //给结点内容赋值
    p->data = e;          //数据域赋值
    p->next = NULL;        //指针域
 
    return p;
}
 
 
//链表判空
int list_empty(NodePtr L)
{
    return L->next == NULL;
}
 
//头插
int list_insert_head(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L)
    {
        printf("链表不合法\n");
        return -1;
    }
 
    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }
 
    //头插逻辑
    p->next = L->next;
    L->next = p;
    
    
    //表的变化
    L->len ++;
    printf("头插成功\n");
    return 0;
}
 
 
//链表遍历函数
int list_show(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("遍历失败\n");
        return -1;
    }
    
    printf("链表中的元素分别是：");
    //遍历逻辑
    NodePtr q = L->next;   //定义遍历指针从第一个结点出发
    while(q != NULL)
    {
        //输出数据域
        printf("%d\t", q->data);
 
        q = q->next;    //指针向后偏移一个
    }
    printf("\n");
}
 
//通过位置查找结点
NodePtr list_search_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<0 || pos>L->len)
    {
        printf("查找失败\n");
        return NULL;
    }
 
    //查找逻辑
    //定义遍历指针从头结点出发
    NodePtr q = L;
    for(int i=0; i<pos; i++)
    {
        q = q->next;
    }
 
    return q;     //将找到的结点地址返回
}
 
 
 
//任意位置插入
int list_insert_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || pos<1 || pos>L->len+1)
    {
        printf("插入失败\n");
        return -1;
    }
    
    //申请结点封装数据
    NodePtr p = apply_node(e);
    if(NULL==p)
    {
        return -1;
    }
    
    //调用函数查找前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //插入逻辑
    p->next = q->next;
    q->next = p;
    
    //表的变化
    L->len++;
    printf("插入成功\n");
    return 0;
}
 
//链表头删
int list_delete_head(NodePtr L)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("删除失败\n");
        return -1;
    }
    
    //删除三部曲
    NodePtr p = L->next;    //标记
    L->next = p->next;  //L->next->next  孤立
    free(p);            //释放
    p = NULL;
 
    //表长变化
    L->len--;
 
    printf("头删成功\n");
    return 0;
}
 
//链表任意位置删除
int list_delete_pos(NodePtr L, int pos)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("删除失败\n");
        return -1;
    }
    
    //找到前驱结点
    NodePtr q = list_search_pos(L, pos-1);
    
    //删除逻辑
    NodePtr p = q->next;           //标记
    q->next = q->next->next;   //p->next 孤立
    free(p);                   //释放
    p = NULL;
 
    
    //表的变化
    L->len--;
    printf("删除成功\n");
    return 0;
}
 
 
//链表按值查找返回位置
int list_search_value(NodePtr L, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("查找失败\n");
        return -1;
    }
    
    //查找逻辑
    //定义遍历指针从第一个结点出发
    NodePtr q = L->next;
    for(int index=1; index<=L->len; index++)
    {
        //判断当前结点的值是否为要找的数据
        if(q->data == e)
        {
            return index;
        }
 
        q = q->next;     //继续向后遍历
    }
 
    //程序执行至此，表示没找到
    printf("没找到\n");
    return -1;
}
 
 
//链表按位置进行修改
int list_update_pos(NodePtr L, int pos, datatype e)
{
    //判断逻辑
    if(NULL==L || list_empty(L) || pos<1 || pos>L->len)
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按位置查找逻辑
    NodePtr p = list_search_pos(L, pos);
    
    //修改逻辑
    p->data = e;
 
    printf("修改成功\n");
    return 0;
}
 
 
 
//按值进行修改
int list_update_value(NodePtr L, datatype old_e, datatype new_e)
{
    //判断逻辑
    if(NULL==L || list_empty(L))
    {
        printf("修改失败\n");
        return -1;
    }
    
    //按值查找位置
    int res = list_search_value(L, old_e);
    if(res == -1)
    {
        printf("没有要修改的值\n");
        return -1;
    }
    
    //按位置修改
    list_update_pos(L, res, new_e);
    
    printf("修改成功\n");
    return 0;
}
 
 
 
//将链表进行翻转
void list_reverse(NodePtr L)
{
    //判断逻辑
    if(NULL==L || L->len<=1)
    {
        printf("翻转失败\n");
        return ;
    }
    
    //翻转逻辑
    NodePtr H = L->next;   //将链表元素进行托付
 
    L->next = NULL;        //自己白手起家
 
    NodePtr p = NULL;         //结点的搬运工
 
    while(H != NULL)
    {
        p = H;      //搬运第一个结点
        H = H->next;     //头指针后移
 
        //将p以头插的方式放入L中
        p->next = L->next;
        L->next = p;
    }
 
    printf("翻转成功\n");
    
}
 
//释放链表
void list_destroy(NodePtr L)
{
    //判断逻辑
    if(NULL == L)
    {
        return;
    }
 
    //将所有结点进行释放
    while(!list_empty(L))
    {
        //头删
        list_delete_head(L);
    }
 
    //释放头结点
    free(L);
    L = NULL;
 
    printf("释放成功\n");
}
 
3>    main.c
Plain Text
自动换行

#include"linklist.h"
 
int main(int argc, const char *argv[])
{
    
    //调用函数创建一个链表
    NodePtr L = list_create();
    if(NULL == L)
    {
        return -1;
    }
 
    //调用头插函数
    list_insert_head(L, 520);
    list_insert_head(L, 1314);
    list_insert_head(L, 666);
    list_insert_head(L, 999);
    
    //调用遍历函数
    list_show(L);
 
    //调用任意位置插入函数
    list_insert_pos(L, 1, 100);
    list_insert_pos(L, 3, 100);
    list_insert_pos(L, L->len+1, 100);
    list_show(L);
 
    //调用头删函数
    list_delete_head(L);
    list_delete_head(L);
    list_show(L);
 
    //调用删除函数
    list_delete_pos(L, 1);
    list_delete_pos(L, 2);
    list_delete_pos(L, L->len);
    list_show(L);
 
    //调用按值查找位置
    int res = list_search_value(L, 666);
    if(res != -1)
    {
        printf("您要找的数据在链表的第%d个位置\n", res);
    }
 
    //调用按位置进行修改函数
    list_update_pos(L, 1, 12345);
    list_show(L);
 
    //调用按值修改函数
    list_update_value(L, 12345, 6789);
    list_show(L);
 
    //调用翻转函数
    list_reverse(L);
    list_show(L);
 
    //调用释放函数
    list_destroy(L);
    L = NULL;
 
 
    return 0;
}

链表的排序

int pai(NodePtrL)
{
  if (L == NULL || L->len <= 1)
  {
    printf("排序失败");
    return -1;
  }
  for (int i = 1; i < L->len; i++)
  {
   NodePtr a = L;
    while (a->next->next != NULL)
    {
      if (a->next->data > a->next->next->data)
      {
        NodePtr s = a->next;
        a->next = a->next ->next;
        s->next= a->next->next;
        a->next->next= s;
      }
      a = a->next;
    }
  }
  printf("排序成功\n");
  return 0;
}

链表反转递归

int list_turn(Node_ptr L)
{
  static int i=0;//插入位置
  node_ptr a = L->next;
    if(L->len==i+1)//结束条件
   {
     L=a;
     i=0;//i的初始化
     return 0;
   }
  while (a->next->next != NULL)//找到倒数第二个元素
  {
    a = a->next;
  } 
   i++;
list_insert_pos(L, i,a->next->data);//
  L->len--;
  a->next = NULL;//最后一个元素置空
  return list_turn(L);
}

text.h

#ifndef MAX
#define MAX 100 //班级最大值
//定义学生类型
struct Stu
{
    char name[20];//姓名
    int age;//年龄
    double score;//成绩
};
//定义班级类型
struct Class
{
    struct Stu student[MAX];       //存放学生的容器
    int size;                      //实际人数
};
void *create(int sum);//创造结构体
void in(struct Class *q);//输入
void print(struct Class *q);//输出
void ch(struct Class *q);//选择最好与最差
void paixun(struct Class *q);//降序排序
void destroy(struct Class *q);//销毁
int  list_add(struct Class *q,struct Stu e);
int  list_delete(struct Class *q,int pos);
int  list_find(struct Class *q,char e[]);
int  list_gai(struct Class *q,int pos, struct Stu e);
int inserts(struct Class *q,int pos,struct Stu e);
#endif
ee.c

#include <myhead.h>
#include "text.h"
void *create(int sum)
{
    struct Class *ptr = (struct Class *)malloc(sizeof(struct Class) * sum); //定义一个结构体指针接受开辟的堆区空间
    if (NULL == ptr)                                                        //实际空间为0
    {
        printf("申请失败\n");
        return NULL;
    }
    //程序执行至此，表示内存申请成功
    //给内存空间进行初始化
    memset(ptr, 0, sizeof(int) * sum);

    //将内存地址返回
    return ptr;
}
void in(struct Class *q)
{
    for (int i = 0; i < q->size; i++) //遍历结构体的student数组
    {
        printf("请输入第%d位学生姓名\n", i + 1);
        scanf("%s", q->student[i].name);
        printf("请输入第%d位学生年龄\n", i + 1);
        scanf("%d", &q->student[i].age);
        printf("请输入第%d位学生的成绩\n", i + 1);
        scanf("%lf", &q->student[i].score);
    }
}
void print(struct Class *q)
{
    if (q == NULL) //无数据
    {
        printf("输出失败\n");
        return;
    }
    printf("姓名\t年龄\t成绩\n");     //打印开头名称
    for (int i = 0; i < q->size; i++) //遍历结构体的student数组
    {

        printf("%s\t%d\t%.2f\n", q->student[i].name, q->student[i].age, q->student[i].score); //输出各个数据
    }
}
void ch(struct Class *q)
{
    if (q == NULL) //数据为空无输出
    {
        printf("选择失败\n");
        return;
    }
    int maxi = 0, mini = 0;           //定义最大最小值小标
    for (int i = 0; i < q->size; i++) //遍历结构体的student数组
    {
        if (q->student[maxi].score < q->student[i].score) //成绩最大值比数组中数据小
        {
            maxi = i; //下标转移
        }
        if (q->student[mini].score > q->student[i].score) //成绩最小值比数组中数据大
        {
            mini = i; //下标转移
        }
    }
    printf("成绩最高学生姓名%s\t年龄%d\t成绩%.2f\n", q->student[maxi].name, q->student[maxi].age, q->student[maxi].score); //输出最好学生的信息
    printf("成绩最低学生姓名%s\t年龄%d\t成绩%.2f\n", q->student[mini].name, q->student[mini].age, q->student[mini].score); //输出最差学生的信息
}
void paixun(struct Class *q)
{
    for (int i = 1; i < q->size; i++) //外循环
    {
        for (int j = 0; j < q->size - 1; j++)                  //遍历结构体的student数组
            if (q->student[j].score < q->student[j + 1].score) //读取student[j]的score与student[j+1]的score进行比较
            {
                struct Stu temp;                       //定义一个学生类型
                strcpy(temp.name, q->student[j].name); //将student[j]赋值给temp
                temp.age = q->student[j].age;
                temp.score = q->student[j].score;
                strcpy(q->student[j].name, q->student[j + 1].name); //将student[j+1]赋值给student[j]
                q->student[j].age = q->student[j + 1].age;
                q->student[j].score = q->student[j + 1].score;
                strcpy(q->student[j + 1].name, temp.name); //将temp赋值给student[j+1]
                q->student[j + 1].age = temp.age;
                q->student[j + 1].score = temp.score;
            }
    }
    printf("排序成功\n"); //提示成功
}
void destroy(struct Class *q)
{
    //释放内存
    if (NULL != q)
    {
        free(q); //释放空间
        q = NULL;
    }
}
int list_add(struct Class *q, struct Stu e)
{
    if (NULL == q )
    {
        printf("添加失败\n");
        return -1;
    }
    q->student[q->size].age = e.age;
    q->student[q->size].score = e.score;
    strcpy(q->student[q->size].name, e.name);
    q->size++;
    printf("添加成功\n");
}
int list_delete(struct Class *q, int pos)
{
    if (NULL == q || pos < 0 || pos >= q->size)
    {
        printf("删除失败\n");
        return -1;
    }
    for (int i = pos + 1; i < q->size; i++)
    {
        q->student[i - 1].age = q->student[i].age;
        q->student[i - 1].score = q->student[i].score;
        strcpy(q->student[i - 1].name, q->student[i].name);
    }
    q->size-- ;
    printf("删除成功\n");
    return 0;
}
int list_find(struct Class *q, char e[])
{
    if (q == NULL)
    {
        return -1;
    }
    for (int i = 0; i < q->size; i++)
    {
        if (strcmp(e,q->student[i].name)==0)
        {
            return i;
        }
    }
    printf("没找到\n");
    return -1;

}
int list_gai(struct Class *q, int pos, struct Stu e)
{
    if (q == NULL || pos >= q->size)
    {
        return -1;
    }
    q->student[pos].score = e.score;
    q->student[pos].age=e.age;
    strcpy(q->student[pos].name,e.name);

    printf("修改成功");
    return 0;
}
int inserts(struct Class *q, int pos, struct Stu e)
{
    if (NULL == q || pos > q->size || pos < 0)
    {
        printf("插入失败\n");
        return -1;
    }
    for (int i = q->size -1; i >= pos; i--)
    {
        q->student[i +1].age = q->student[i].age;
        q->student[i +1].score = q->student[i].score;
        strcpy(q->student[i +1].name, q->student[i].name);
    }
    q->student[pos].score = e.score;
    q->size++;
    printf("插入成功\n");
}
y.c

#include <myhead.h>
#include "text.h"
int main()
{
    int N = 0;
    int sum = 0;
    int pos = 0;
    struct Stu w;
    char r[20];
    char k = ' ';
    while (1)
    {
        printf("*************菜单*************\n");
        printf("1>创建班级\n2>班级学生信息录入\n3>将班级学生按成绩进行降序排序\n4>输出班级中成绩最好和最差学生的信息\n5>输出信息\n6>销毁班级\n7>增加学生数据\n8>删除学生数据\n9>修改学生信息\n10>查找学生\n0>退出\n"); //打印菜单
        printf("******************************\n");
        scanf("%d", &N); //接受菜单变量
        switch (N)       //switch语句实现菜单功能
        {
        case 1:
            printf("请输入班级人数\n");
            scanf("%d", &sum); //接受用户输入的数字
            struct Class *q = (struct Class *)create(sum);
            q->size = sum; //sum赋值给结构体中对应变量
            break;
        case 2:
            in(q);
            break;
        case 3:
            paixun(q);
            break;
        case 4:
            ch(q);
            break;
        case 5:
            print(q);
            break;
        case 6:
            destroy(q);
            q = NULL;
            break;
        case 7:
            printf("请输入学生姓名\n");
            scanf("%s", w.name);
            printf("请输入学生年龄\n");
            scanf("%d", &w.age);
            printf("请输入学生的成绩\n");
            scanf("%lf", &w.score);
            list_add(q, w);
            break;
        case 8:
            printf("请输入位置");
            scanf("%d", &pos);
            list_delete(q, pos - 1);
            break;
        case 0:
            return 0; //结束程序
        case 9:

            printf("请输入位置");
            scanf("%d", &pos);
            printf("请输入修改后的学生姓名\n");
            scanf("%s", w.name);
            printf("请输入修改后的学生年龄\n");
            scanf("%d", &w.age);
            printf("请输入修改后的学生的成绩\n");
            scanf("%lf", &w.score);
            list_gai(q, pos - 1, w);
            break;
        case 10:
            printf("请输入要查找的学生姓名\n");
            scanf("%s", r);
            printf(" 在第%d位置\n", list_find(q, r) + 1);
            break;
        default:
            break;
        }
    }
    return 0;
}

湄公河1223
关注
day25
qq_43571222的博客
03-05 582
Day 25 1. Background 今天是学习java的第25天，今天学习的是objectStack，以及用这个实现二叉树的中序遍历。 2. Description 2.1About 今天的代码是先用Object类来实现栈，以实现一个代码实现所有的数据类型的效果。 所以栈的实现的代码直接把之前栈的代码搬过来，然后修修补补即可。 然后就是中序遍历了，这个倒是让我想了很久。 2.2 in-order vistit 我的理解是先建立一个栈，然后创建一个tempNode，用这个来存要遍历的节点。 然后利用栈先
句句真研—每日长难句打卡Day15
道阻且长，行则将至。
09-04 5213
句句真研—每日长难句打卡Day15 补九月一号 参考译文：纽约爱乐乐团决定聘请Alan Gilbert作为下一任总监，这项任命自从2009年突然宣布起就一直是古典音乐届谈论的话题。
cgb2106-day15
cgblpx的博客
08-13 4978
标题 标题 标题
学习Uni-app开发小程序Day15
qq_34080064的博客
05-17 1428
网络请求的方式写法
Java学习day01-day15学习资料
04-05
这份资料包括了day01至day15的学习内容，主要围绕Java编程的核心概念展开。以下是对每个子文件名中涉及知识点的详细解释： 1. **day02**: 这部分可能涉及Java的基础语法，如变量、数据类型、运算符、流程控制语句...
python-day15-day19
03-18
在Python编程语言的学习过程中，"python-day15-day19"这部分内容涵盖了从第15天到第19天的学习笔记。尽管没有提供具体的笔记内容，但我们可以根据通常的Python学习路径来推测涵盖的一些关键知识点。 1. **面向对象...
python课程设计第15天，python-Day15.rar
05-11
在这个压缩包"python-Day15.rar"中，包含的"Day15"文件很可能是这一天课程的所有材料，包括讲义、代码示例和练习题。 首先，我们可能会接触到Python的模块化编程。模块是Python代码的组织单位，允许我们将大型项目...
day15经典案例.rar_C++经典案列
09-15
这个压缩包文件，"day15经典案例.rar"，显然是一个教学资料集合，可能是某个课程或训练营的第15天教学内容，专门探讨C++的经典应用。 【描述】提到"推荐给学习c++的朋友好好研究一下"，这暗示了这些案例不仅适用于...
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1110
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 152
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 918
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 345
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 839
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1195
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1067
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 406
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
JAVA开源项目 在线视频教育平台 计算机毕业设计
as230627的博客
09-14 1047
基于Vue.js和SpringBoot的在线视频教育平台是一个功能丰富的系统，它包括管理后台和用户网页端，为管理员、普通用户和教师角色提供了不同的功能。在管理后台，管理员可以进行用户管理，包括用户信息的增删改查。
ModuleNotFoundError: No module named 'day15'
08-31
ModuleNotFoundError: No module named 'day15' 这是一个Python错误，通常发生在尝试导入名为'day15'的模块时找不到该模块。Python解释器无法找到指定的模块，可能是以下几个原因： 1. **路径问题**：模块所在的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值