第二次作业

最新推荐文章于 2024-06-29 11:23:34 发布
最新推荐文章于 2024-06-29 11:23:34 发布
阅读量68 收藏
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62377787/article/details/121344620
版权 
/*
        Project: single linkeed list (数据结构 单链表)
        Date:    2021-10-7 09:26:57
        Author:  Frank Wang
        InitList(LinkList &L) 参数：单链表L 功能：初始化 时间复杂度 O(1)
        ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度 时间复杂度O(n)
        ListInsert(LinkList &L,int i,ElemType e)
        ListDelete(LinkList &L,int i) 参数：单链表L，位置i 功能：删除位置i元素 时间复杂度O(n)[加入了查找]
                                      若已知p指针指向的删除 最好是O(1),因为可以与后继结点交换数据域，然后删除后继结点。
                                      最坏是O(n),即从头查找p之前的结点,然后删除p所指结点
        LocateElem(LinkList L,ElemType e) 参数：单链表L，元素e 功能：查找第一个等于e的元素，返回指针 时间复杂度O(n)
    */
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cmath>
    #include<iostream>
    using namespace std;
    #define Status int
    #define ElemType int
    //单链表结点数据结构
    typedef struct Node
    {
        ElemType data;//数据域
        struct Node *next;//指针域
    }LNode,*LinkList;
    //**************************基本操作函数***************************//
    //初始化函数
    Status InitList(LinkList &L)
    {
     L = new LNode;//生成头结点 这样删除等操作就不必分第一个结点和其他了
     L->next = NULL;
     return 1;
    }
    //获取单链表长度 头结点无数据，不算
    int ListLength(LinkList L)
    {
        LinkList p=L;int sum=0;
        while(p)
        {
         sum++;
         p=p->next;
        }
        return sum-1;//去除头结点
    }
    //哪种插入法？？？？后插
    bool ListInsert(LinkList &L,int i,ElemType e)
    {
        LNode* s;LinkList p=L;int j=0;
        while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
        {
         p=p->next;
         ++j;
        }
        if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
        {
            printf("插入位置无效！！！\n");
            return false;
        }
        s=new LNode;
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }



    //删除函数 删除位置i的结点 即删除i-1之后的结点
    bool ListDelete(LinkList &L,int i)
    {
         LNode* s;LinkList p=L;int j=0;
        LinkList q;
        while(p&&(j<i-1))//j指到i-1位置
        {
         p=p->next;
         ++j;
        }
        if(!(p->next)||j>i-1)//i<1或者i>ListLength(L)时,删除位置无效
        {
            printf("删除位置无效！！！\n");
            return false;
        }
        q=p->next;
        p->next=q->next;
        free(q);//释放空间
        return true;
    }
    //查找函数 按值查找 查找第一个等于e的结点 成功返回该结点指针，否则返回NULL
    LNode *LocateElem(LinkList L,ElemType e)
    {
        LNode *p=L;
        while(p&&(p->data!=e))
        {
            p=p->next;
        }
        return p;
    }
    //**************************功能实现函数**************************//
    void PrintList(LinkList L);
    bool insert2(LinkList &L,int i,ElemType e)
{
    LNode* s;LinkList p = L , last;int j=0;
    while(p&&(j<i))//j指到i位置或者p已经到最后时跳出
    {
		 last = p;
		 p = p -> next;
		 ++ j;
    }
    //出来的时候j = i,或者已经走到最后了
    if(!p && j == i - 1) //走到最后，并且在i - 1位置
    {
    	s = new LNode;
		s -> data = e;
		s -> next = p -> next;
		p -> next = s;
		return true;
    }
    if (!p && j != i)
	{
		printf("插入位置无效！！！\n");
		return false;
	}
    s = new LNode;
    last -> next = s;
    s -> data = e;
    s -> next = p;
}

    void sort(LinkList &L)//链表选择排序
    {
    struct Node *p;  //=(struct Node*)malloc(sizeof(struct Node));
    struct Node *q;   //=(struct Node*)malloc(sizeof(struct Node));
    ElemType t;
    for(p=L->next; p!=NULL ; p=p->next)//选定的位置，从第一个位置开始
    {
        for(q=p->next;q!=NULL;q=q->next)//每次遍历一遍链表，只要比选定位置的数据小就交换
        {
            if(q->data<p->data)
            {
                t=q->data;
                q->data=p->data;
                p->data=t;
            }
        }
    }
    PrintList(L);
}

    //遍历输出函数
    void PrintList(LinkList L)
    {
        LinkList p=L->next;//跳过头结点
        if(ListLength(L))
        {
            printf("当前单链表所有元素:");
            while(p)
            {
                printf("%d ",p->data);
                p=p->next;
            }
            printf("\n");
        }
        else
        {
            printf("当前单链表已空！\n");
        }
    }
    //插入功能函数 调用ListInsert插入
    void Insert(LinkList &L)
    {
      int place;ElemType e;bool flag;
      printf("请输入要插入的位置(从1开始)及元素:\n");
      scanf("%d%d",&place,&e);
      flag=ListInsert(L,place,e);
      if(flag)
      {
        printf("插入成功！！！\n");
        PrintList(L);
      }
    }
    void Insert2(LinkList &L)
    {
      int place;ElemType e;bool flag;
      printf("请输入要插入的位置(从1开始)及元素:\n");
      scanf("%d%d",&place,&e);
      flag=insert2(L,place,e);
      if(flag)
      {
        printf("插入成功！！！\n");
        PrintList(L);
      }
    }
    //删除功能函数 调用ListDelete删除
    void Delete(LinkList L)
    {
      int place;bool flag;
      printf("请输入要删除的位置(从1开始):\n");
      scanf("%d",&place);
      flag=ListDelete(L,place);
      if(flag)
      {
        printf("删除成功！！！\n");
        PrintList(L);
      }
    }
    //查找功能函数 调用LocateElem查找
    void Search(LinkList L)
    {
      ElemType e;LNode *q;
      printf("请输入要查找的值:\n");
      scanf("%d",&e);
      q=LocateElem(L,e);
      if(q)
      {
        printf("找到该元素！\n");
      }
      else
        printf("未找到该元素！\n");
    }
    //菜单
    void menu()
    {
       printf("********1.后插    2.删除*********\n");
       printf("********3.查找    4.输出*********\n");
       printf("********5.退出    6.前插*********\n");
       printf("********7.排序          *********\n");
    }
    //主函数
    int main()
    {
     LinkList L;int choice;

     InitList(L);
     while(1)
     {
      menu();
      printf("请输入菜单序号：\n");
      scanf("%d",&choice);
      if(choice==5) break;
      switch(choice)
      {

      case 1:Insert(L);break;
      case 2:Delete(L);break;
      case 3:Search(L);break;
      case 4:PrintList(L);break;
      case 6:Insert2(L);break;
      case 7:sort(L);break;
      default:printf("输入错误！！！\n");

      }
     }
     return 0;
    }

结构体到单链表的过渡

#include<stdio.h>
#include<stdlib.h>
int num=0;
struct student
{
    char name[20];
    int score;
};
typedef struct Node
{
    struct student data;//数据域
    struct Node *next;//指针域
}List;
List *CreateHead()//创造头节点
{
    List *headNode=(List *)malloc(sizeof(List));
    headNode->next=NULL;
    return headNode;
};
List *CreateNode(struct student data)
{
    List *newNode=(List *)malloc(sizeof(List));
    newNode->data=data;
    newNode->next=NULL;
    return newNode;
}
void insertNodeByHead(List *headNode,struct student data)//链表的前插
{
    List *newNode=CreateNode(data);
    newNode->next=headNode->next;
    headNode->next=newNode;
    num++;
}
void insertNodeByTail(List *headNode,struct student data)//链表的后插
{
    List *p=headNode;
    List *newNode=CreateNode(data);
    while(p->next!=NULL)
    {
        p=p->next;
    }
    p->next=newNode;
    num++;
}
void del_Node(List *headNode)//删除节点
{
    int i,n=0;
    List *p=headNode,*ptr;
    printf("请输入你要修改的节点位置:");
    scanf("%d",&i);
    if(i<1||i>num)
    {
        printf("删除位置错误\n");
        return;
    }
    while(p->next!=NULL)
    {
        ptr=p;
        p=p->next;
        n++;
        if(n==i)
        {
            ptr->next=p->next;
            break;
        }
    }
    free(p);
    num--;
}
void search_Node(List *headNode)//节点位置查询
{
    int i,k=0;
    List *p=headNode;
    printf("请输入你要搜索的位置:");
    scanf("%d",&i);
    if(i<1||i>num)
    {
        printf("搜索位置有误\n");
        return;
    }
    else
    {
        while(p->next!=NULL)
        {
            p=p->next;
            k++;
            if(k==i)
            {
                printf("姓名:%s 分数:%d\n",p->data.name,p->data.score);
                printf("搜索完毕");
                break;
            }
        }
    }
}
void printfList(List *headNode)//打印链表
{
    List *pmove=headNode->next;
    printf("name\tscore\n");
    while(pmove!=NULL)
    {
        printf("%s\t%d\n",pmove->data.name,pmove->data.score);
       pmove=pmove->next;
    }
}
void sort_list(List *headNode)//链表排序
{
    int i,j;
    struct student temp;
    List *L=headNode;
    List *p,*ptr;
    for(i=0; i<num-1; i++)
    {
        L=headNode->next;
        {
            for(j=0; j<num-i-1; j++)
            {
                p=L;//前缀
                ptr=L->next;//后缀
                if(p->data.score>ptr->data.score)
                {
                    temp=p->data;
                    p->data=ptr->data;
                    ptr->data=temp;
                }
                L=L->next;
            }
        }
    }
}
void menu(List *headNode)
{
    struct student stu;
    char choice;
    while(1)
    {
    printf("请输入你想要选择的功能:\n");
    printf("1.前插\n");
    printf("2.删除\n");
    printf("3.查找\n");
    printf("4.输出\n");
    printf("5.后插\n");
    printf("6.排序\n");
    printf("7.退出\n");
    setbuf(stdin,NULL);
    scanf("%c",&choice);
    switch(choice)
    {
    case '1':
        printf("请输入姓名和分数");
        setbuf(stdin,NULL);
        scanf("%s %d",stu.name,&stu.score);
        insertNodeByHead(headNode,stu);
        break;
    case '2':
        del_Node(headNode);
        break;
    case '3':
        search_Node(headNode);
        break;
    case '4':
        printfList(headNode);
        break;
    case '5':
        printf("请输入姓名和分数");
        setbuf(stdin,NULL);
        scanf("%s %d",stu.name,&stu.score);
        insertNodeByTail(headNode,stu);
        break;
    case '6':
        sort_list(headNode);
        printfList(headNode);
        break;
    case '7':
        exit(0);
    default:
        printf("请在(1~7之间输入)\n");
        return;
    }
    }

}
int main()
{
    List *ListNOde=CreateHead();
    while(1)
    {
         menu(ListNOde);
    }
    return 0;

}

曾经拥有的
关注
单链表基本练习-初始化、插入和输出
兔子王
11-07 737
【问题描述】 设有头结点单链表，实现单链表的初始化、插入和输出算法。 【输入形式】 第一行输入一个N（N大于等于1，小于1000），一个M（N大于等于1，小于1000）； 第二行输入N个整数，以空格作为分隔，创建长度为N的单链表； 接着输入M组数据：pos和e，以空格分隔，分别表示插入位置和插入元素的值。 【输出形式】 若插入成功，输出yes；若插入不成功，输出error。 最后输出单链表所有元素（以空格分隔）。
数据结构--单链表
WX_timi的博客
02-07 602
数据结构–单链表 InitList(LinkList &L) 参数：单链表L 功能：初始化 时间复杂度 O(1) ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度 时间复杂度O(n) ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插 时间复杂度O(n)[加入了查找]...
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
Yhisken的博客
09-30 697
[C语言、C++]数据结构作业：线性表-单链表(无头节点)的基本操作
数据结构作业：单链表
m0_62957825的博客
04-29 730
首先附上老师的代码 #include <stdio.h> #include <malloc.h> /** * Linked list of characters. The key is data. */ typedef struct LinkNode{ char data; struct LinkNode *next; } LNode, *LinkList, *NodePtr; /** * Initialize the list with a header.
数据结构作业_单链表
落末的博客
05-03 453
数据结构第二次作业：单链表。 #include <stdio.h> #include <stdlib.h> //结构体的定义 typedef int elemtype; typedef struct node { elemtype data; struct node * next; } LinkList; LinkList *head; //用头插法...
江苏开放大学计算机应用基础形考第二次作业答案.pdf
07-14
江苏开放大学计算机应用基础形考第二次作业答案.pdf 这是江苏开放大学计算机应用基础课程的第二次作业答案，旨在指导学生学习 Excel 制作行业状况调查表的实践目标。该作业分为两个部分：企业总体状况和企业人才...
川大网络教育-政治科学原理第一次作业第二次作业.doc
12-06
川大网络教育-政治科学原理第一次作业第二次作业.doc
第二次作业.zip
11-24
第二次作业.zip
《计算机应用基础》(二)-第二次作业.pdf
11-20
《计算机应用基础》(二)-第二次作业
数据结构作业--单链表
刘索隆ʕ•ᴥ•ʔ的博客
09-18 197
package 单链表1; import javax.management.StandardEmitterMBean; //我的单链表类 public class MyList { //设置了头结点，让其数据为-2147483648即不可能的数 public Node head = new Node(-2147483648); //初始长度为零 public int length = 0; //内部类---节点类 public class Node {
数据结构作业5--单链表
qq_41464448的博客
09-19 2140
6-1 带头结点的单链表就地逆置 （10 分） 本题要求编写函数实现带头结点的单链线性表的就地逆置操作函数。L是一个带头结点的单链表，函数ListReverse_L(LinkList &amp;L)要求在不新开辟节点的前提下将单链表中的元素进行逆置，如原单链表元素依次为1,2,3,4，则逆置后为4,3,2,1。 函数接口定义： void ListReverse_L(LinkList &am...
数据结构作业2（单链表）
weixin_50089904的博客
05-03 452
数据结构 单链表
单链表的基本操作(初始化，插入，删除等）
Mr_zhou..的博客
09-01 9183
单链表：单链表是线性表链式存储的一种形式，其中的结点一般含有两个域，一个是存放数据信息的数据域(Data)，另一个是指向该结点的后继结点存放地址的指针域(Next)，一个单链表必须有一个首指针指向单链表中的第一个结点。 单链表的结构如下所示： typedef int DataType; typedef struct Node {     DataType data;  //存放数据信息的数...
【C语言习题】用程序实现“单链表”的初始化、输入、输出、清空、销毁数据、取值、查找、插入、删除数据...
qq_42910355的博客
04-17 1366
​ 在上次练习的的基础上实现“单链表”的取值、查找、插入、删除数据... 【要求：数据元素（ElemType）为结构体类型（如：Student，成员包括——学号、姓名、成绩等 ）】 个人解法如下： 1.自定义的头文件 #include <stdlib.h> #include <string.h> #define M 21 //开始菜单 void menu() { printf(" 欢迎访问学生管理系统\n"); printf("\n");
数据结构与算法课程记录——单链表作业1：学生管理系统
ZHY_Kelly的博客
06-08 541
这是一个记录贴，记录一下我在b站学习数据结构课程的作业和一些小小的心得。视频课程是懒猫老师的，老师真的讲得很细，也很认真，附上链接：https://www.bilibili.com/read/cv8013121；这是一个专栏链接，里面记录了每一个课程，都可以点进去看（三连走起！） 首先是第一个作业：用单链表完成一个学生管理系统 头文件： node.h #pragma once //#include <iostream> //using namespace std; #ifndef NODE_H
数据结构：单链表
xiaoyu1381的博客
08-08 123
单链表
数据结构:单链表
最新发布
weixin_74150890的博客
06-29 519
/ 定义单链表节点数据类型为整型// 定义单链表节点结构体// 节点数据// 指向下一个节点的指针。
数据结构 之 单链表
cyt
02-08 371
链表 动态数组是一种顺序存储元素的数据结构，其元素存放在一个连续的内存地址中，这样在查找的时候便可以直接根据首元素的地址 + 偏移量 来确定任何位置的元素。动态数组在查找的时候占据优势，但是在删除元素、指定位置添加元素的时候却要面临着移动元素的开销。 链表是一种链式存储元素的数据结构，其节点元素中存放了下一个元素的地址，这样的存储模型便完美解决了在删除和添加操作较多的场景下面使用动态数组而带来的额外开销。 单链表 单链表是最普通的链表，其每个节点由数据部分、下一个元素的指针组成，通过每个节点的next指针
数据科学导论第二次作业解析
资源摘要信息:"数据科学导论第二次作业" 数据科学是一门涉及多个学科的交叉领域，它利用科学方法、过程、算法和系统从结构化和非结构化数据中提取知识和见解。第二次作业是数据科学导论课程的学习过程中一个重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值