【实验报告】实验二链表实验奇偶数分类

已于 2022-02-28 20:41:38 修改
阅读量1.9k 收藏 3
点赞数 2
分类专栏： 数据结构实验报告 文章标签： 链表 分类 数据结构
于 2022-01-29 22:57:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/whyxian/article/details/122748709
版权

链表实现奇偶数分类

一、需求分析

1、数据存储结构为链表
2、输入形式为键盘包括数字1-9、空格、和回车
3、输出形式为打印形式
4、包含链表的基本操作
5、能够完成指定要求的排序操作
6、能够从一个链表中分离出奇数和偶数
7、能够删除非指定数字

二、概要设计

一、抽象数据类型定义

ADT numbers{
数据对象：{}
数据关系：{<a,b>}
基本操作：
MakeNode(Link &p, ElemType e)
操作结果：分配由p指向的值为e的结点
FreeNode(Link &p)
操作结果：释放p所指的结点
InitList(LinkList &L)
操作结果：初始化一个链表L
ClearList(LinkList &L)
初始条件：链表存在
操作结果：链表L重置为空表，并释放原链表的结点空间
DestroyList(LinkList &L)
初始条件：链表L存在
操作结果：销毁链表L，L不再存在
InsFirst(LinkList &L,Link s)
初始条件：链表L存在
操作结果：将s所指结点插入在第一个结点之前
GetCurElem(Link p)
操作结果：返回p所指结点中数据元素的值
Compare(Link p1, Link p2)
操作结果：如果p1所指元素大于p2则返回TURE，否则返回FALSE
ExchangeData(Link &p1,Link &p2)
操作结果：交换两个结点的数据
sort(LinkList &L)
操作结果：将链表排序为非递增链表
DeleteNode(LinkList &L, Link s)
初始条件：链表L不为空
操作结果：删除s所指结点
PrintList(LinkList &L)
初始条件：链表L存在
操作结果：在屏幕上打印出链表中的元素
}

二、宏定义部分

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

三、主程序流程图

在这里插入图片描述

四、程序结构图

在这里插入图片描述

三、详细设计

一、数据类型设计

/*顺序表的定义/
typedef struct LNode{ // 结点类型
ElemType data; //数据域
struct LNode *next; //指针域
} *Link, *Position;

typedef struct { // 链表类型
Link head; // 头结点
Link tail; // 最后一个结点
int len; // 线性链表中的数据元素格式
} LinkList;

二、数据操作

Status MakeNode(Link &p, ElemType e){
// 分配由p指向的值为e的结点。若分配失败，则返回ERROR
p = (Link)malloc(sizeof(LNode));
if(!p){
return ERROR;
}
p->data = e;
}

void FreeNode(Link &p){
// 释放p所指结点
free§;
p = NULL;
}

Status InitList(LinkList &L){
// 构造一个空的线性链表L
Link p;
p = (Link)malloc(sizeof(LNode)); // 生成头结点
if§{
p->next = NULL;
L.head = L.tail = p;
L.len = 0;
}
else
return ERROR;
}

void ClearList(LinkList &L){ // 将线性链表L重置为空表，并释放原链表的结点空间
Link p,q;
if(L.head!=L.tail) // 不是空表
{
p=q=L.head->next;
L.head->next=NULL;
while(p!=L.tail)
{
p=q->next;
free(q);
q=p;
}
free(q);
L.tail=L.head;
L.len=0;
}
}

Status DestroyList(LinkList &L){ // 销毁线性链表L，L不再存在(见图2.44)
ClearList(L); // 清空链表
FreeNode(L.head);
L.tail=NULL;
L.len=0;
}

Status InsFirst(LinkList &L,Link s){ // 形参增加L,因为需修改L
// h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前
Link h = L.head;
s->next=h->next;
h->next=s;
if(h==L.tail) // h指向尾结点
L.tail=h->next; // 修改尾指针
L.len++;
}

Status Compare(Link p1, Link p2) {
if(p1->data > p2->data){
return TRUE;
}else{
return FALSE;
}
}

void ExchangeData(Link &p1,Link &p2){ // 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
ElemType temp = p1->data;
p1->data = p2->data;
p2->data = temp;
}

ElemType GetCurElem(Link p){ // 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值
return p->data;
}

void sort(LinkList &L){
for (int i = 0; i < L.len; i++)
{
Link p2 = L.head->next;
if(p2->next==NULL){
return;
}
Link p1 = L.head->next->next;
for (int j = 0; j <= L.len-2; j++)
{
if(Compare(p1,p2)){
ExchangeData(p1, p2);
}
p1 = p1->next;
p2 = p2->next;
}

}

}

Status DeleteNode(LinkList &L, Link s){
if(s == L.head || L.head == L.tail){
return FALSE;
}
if(s == L.tail){
Link p = L.head;
while(p->next!=L.tail){
p = p->next;
}
p->next = NULL;
L.tail = p;
FreeNode(s);
L.len–;
return TRUE;
}
Link p = L.head;
while(p->next!=s){
p = p->next;
}
p->next = p->next->next;
FreeNode(s);
L.len–;
return TRUE;
}

void PrintList(LinkList &L){
Link p = L.head->next;
for (int i = 0; i < L.len; i++)
{
printf("%d ", p->data);
p = p->next;
}

}

三、运算功能

void Function_1(LinkList &L, int mink, int maxk){//筛选出指定范围的数据
Link p1 = L.head;
while (p1->next!=NULL)
{
Link p2 = p1;
p1 = p1->next;
if(p1->data<mink || p1->data>maxk){
DeleteNode(L, p1);
p1 = p2;
}
}
}
void Function_2(LinkList &L_A, LinkList &L_B, LinkList &L_C){//分离出奇偶数
Link p = L_A.head;
while (p->next!=NULL)
{
p = p->next;
if (p->data%2==1)
{
Link s;
MakeNode(s, p->data);
InsFirst(L_B, s);
}
else
{
Link s;
MakeNode(s, p->data);
InsFirst(L_C, s);
}
}
}

四、主程序

int main(){
LinkList L_A, L_B, L_C;
InitList(L_A);
InitList(L_B);
InitList(L_C);
char a;
int b;
scanf("%d", &b);
scanf("%c", &a);
while (a!=’\n’)
{
Link p;
MakeNode(p, b);
InsFirst(L_A, p);
scanf("%d", &b);
scanf("%c", &a);
}
Link p;
MakeNode(p, b);
InsFirst(L_A, p);
sort(L_A);
Function_1(L_A, 0, 20);
Function_2(L_A, L_B, L_C);
sort(L_B);
sort(L_C);
printf("\nL_A:");
PrintList(L_A);
printf("\nL_B:");
PrintList(L_B);
printf("\nL_C:");
PrintList(L_C);
}

四、调试分析

一、主要问题与解决方案
1、发现排序出现问题，调试后发现是遍历链表时循环一遍结束后未让指针指向下一个元素。
2、筛选函数出现报错，调试后发现指针在结点删除后变成空指针，未重新指向下一个结点，导致报错。

五、用户使用说明

一、本程序运行环境为Windows操作系统下的Microsoft Visual C++ 6.0。
二、在VC环境下打开程序后，输入整数，并用一个空格分隔，敲击“回车符”输入，即可以显示要求的结果。
三、按下任意键以继续。

六、测试结果

在这里插入图片描述

七、附录

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
typedef int Status;  /**Status是函数类型，其值是函数结果状态代码，如OK等*/
typedef int ElemType;

/**顺序表的定义*/
typedef struct LNode{ // 结点类型
    ElemType data; //数据域
    struct LNode *next; //指针域
} *Link, *Position;

typedef struct { // 链表类型
    Link head; // 头结点
    Link tail; // 最后一个结点
    int len; // 线性链表中的数据元素格式
} LinkList;

Status MakeNode(Link &p, ElemType e){
    // 分配由p指向的值为e的结点。若分配失败，则返回ERROR
    p = (Link)malloc(sizeof(LNode));
    if(!p){
        return ERROR;
    }
    p->data = e;
}

void FreeNode(Link &p){
    // 释放p所指结点
    free(p);
    p = NULL;
}

Status InitList(LinkList &L){
    // 构造一个空的线性链表L
    Link p;
    p = (Link)malloc(sizeof(LNode)); // 生成头结点
    if(p){
        p->next = NULL;
        L.head = L.tail = p;
        L.len = 0;
    }
    else
        return ERROR;
}

void ClearList(LinkList &L){ // 将线性链表L重置为空表，并释放原链表的结点空间
    Link p,q;
    if(L.head!=L.tail) // 不是空表
    {
        p=q=L.head->next;
        L.head->next=NULL;
        while(p!=L.tail)
        {
            p=q->next;
            free(q);
            q=p;
        }
        free(q);
        L.tail=L.head;
        L.len=0;
    }
}

Status DestroyList(LinkList &L){ // 销毁线性链表L，L不再存在(见图2.44)
    ClearList(L); // 清空链表
    FreeNode(L.head);
    L.tail=NULL;
    L.len=0;
}

Status InsFirst(LinkList &L,Link s){ // 形参增加L,因为需修改L
 // h指向L的一个结点，把h当做头结点，将s所指结点插入在第一个结点之前
    Link h = L.head;
    s->next=h->next;
    h->next=s;
    if(h==L.tail) // h指向尾结点
        L.tail=h->next; // 修改尾指针
    L.len++;
}

Status Compare(Link p1, Link p2) {
    if(p1->data > p2->data){
        return TRUE;
    }else{
        return FALSE;
    }
}

void ExchangeData(Link &p1,Link &p2){ // 已知p指向线性链表中的一个结点，用e更新p所指结点中数据元素的值
    ElemType temp = p1->data;
    p1->data = p2->data;
    p2->data = temp;
}

ElemType GetCurElem(Link p){ // 已知p指向线性链表中的一个结点，返回p所指结点中数据元素的值
    return p->data;
}

void sort(LinkList &L){
    for (int i = 0; i < L.len; i++)
    {
        Link p2 = L.head->next;
        if(p2->next==NULL){
            return;
        }
        Link p1 = L.head->next->next;
        for (int j = 0; j <= L.len-2; j++)
        {
            if(Compare(p1,p2)){
                ExchangeData(p1, p2);
            }
            p1 = p1->next;
            p2 = p2->next;
        }
        
    }
    
}

Status DeleteNode(LinkList &L, Link s){
    if(s == L.head || L.head == L.tail){
        return FALSE;
    }
    if(s == L.tail){
        Link p = L.head;
        while(p->next!=L.tail){
            p = p->next;
        }
        p->next = NULL;
        L.tail = p;
        FreeNode(s);
        L.len--;
        return TRUE;
    }
    Link p = L.head;
    while(p->next!=s){
        p = p->next;
    }
    p->next = p->next->next;
    FreeNode(s);
    L.len--;
    return TRUE;
}

void PrintList(LinkList &L){
    Link p = L.head->next;
    for (int i = 0; i < L.len; i++)
    {
        printf("%d ", p->data);
        p = p->next;
    }
    
}

void Function_1(LinkList &L, int mink, int maxk){
    //筛选出指定范围的数据
    Link p1 = L.head;
    while (p1->next!=NULL)      
    {
        Link p2 = p1;
        p1 = p1->next;
        if(p1->data<mink || p1->data>maxk){
            DeleteNode(L, p1);
            p1 = p2;
        }
    }
    
}

void Function_2(LinkList &L_A, LinkList &L_B, LinkList &L_C){
    //分离出奇数和偶数
    Link p = L_A.head;
    while (p->next!=NULL)
    {
        p = p->next;
        if (p->data%2==1)
        {
            Link s;
            MakeNode(s, p->data);
            InsFirst(L_B, s);
        }
        else
        {
            Link s;
            MakeNode(s, p->data);
            InsFirst(L_C, s);
        }   
    }
    
}


int main(){
    LinkList L_A, L_B, L_C;
    InitList(L_A);
    InitList(L_B);
    InitList(L_C);

    char a;
    int b;
    scanf("%d", &b);
    scanf("%c", &a);
    while (a!='\n')
    {
        Link p;
        MakeNode(p, b);
        InsFirst(L_A, p);
        scanf("%d", &b);
        scanf("%c", &a);
    }
    Link p;
    MakeNode(p, b);
    InsFirst(L_A, p);

    sort(L_A);
    Function_1(L_A, 0, 20);
    Function_2(L_A, L_B, L_C);
    sort(L_B);
    sort(L_C);
    printf("\nL_A:");
    PrintList(L_A);
    printf("\nL_B:");
    PrintList(L_B);
    printf("\nL_C:");
    PrintList(L_C);
}
whyxian
关注
专栏目录
【leetcode/链表】奇偶链表（拆分链表）
qq_43338695的博客
10-15 1720
题目描述： 给定一个单链表，把所有的奇数节点和偶数节点分别排在一起。请注意，这里的奇数节点和偶数节点指的是节点编号的奇偶性，而不是节点的值的奇偶性。 请尝试使用原地算法完成。你的算法的空间复杂度应为 O(1)，时间复杂度应为 O(nodes)，nodes 为节点总数。 示例 1: 输入: 1->2->3->4->5->NULL 输出: 1->3-&gt...
数据结构实验报告 链表
热门推荐
喵头鹰的博客
04-17 1万+
一、实验目的（1）掌握线性表的基本运算在两种存储结构（顺序结构和链式结构）上的实现； （2）掌握线性表的各种操作（建立、插入、删除等）的实现算法；二、实验仪器及环境：PC计算机 windows 7操作系统 CodeBlocks10.05三、实验内容及结果（按照具体实验题目，按照如下格式书写）1．随机产生或键盘输入一组元素，建立一个带头结点的单向链表（无序）。 2．遍历单向链表。 3．把单向链
将链表分割成奇数链表和偶数链表
最新发布
hexinchaode的博客
09-07 666
【代码】将链表分割成奇数链表和偶数链表。
剑指Offer（书）：调整数组顺序使奇数位于偶数前面
weixin_30399871的博客
08-07 134
题目：输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。 public void reOrderArray(int[] array) { for (int i = 0; i < array.length; i++) { int indexEv...
将一个链表分为奇偶两个链表
二哈
06-30 9456
1. 问题描述： 设计一个算法，将一个头结点为A的单链表（其数据域为整数）分解成两个单链表A和B，使得A链表只含有原来链表data域为奇数的节点，而B链表只含有原链表中data域为偶数的节点，而且保持原来的顺序 2. 思路分析： ① 这个问题不是在线网上评测系统上的，所以没有标准的输入和输出数据，只能够通过简单的数据来判断程序的逻辑是否正确，首先在将原来的链表分开之前，我们需要将创建出一个单...
使用链表进行奇偶分排 c语言
qq_61539575的博客
11-26 954
题目内容： 　　使用单向链构建一个有n个节点，输入正整数序列并输出序列，n由键盘输入。然后将偶数节点依次移动到所有的奇数后面，形成一个前面为奇正数序列，后面为偶整数序列的新序列，最后输出这个序列 #include <stdio.h> #include <stdlib.h> typedef struct i { int n; struct i *next; struct i *past; }F; int pd(F *p) { for(;p!=N.
线性表 实验报告.docx
12-31
本实验报告涉及线性表的各种操作，包括顺序表和单链表的实现，以及相关的算法设计与分析。以下是这些操作的详细说明： 1. **顺序表**： - **实现基本运算**：顺序表是用数组来存储线性表的数据结构，支持的基本...
数据结构实验报告链表
06-27
数据结构实验报告主要聚焦于单向链表的操作与应用，链表是一种常见的数据结构，它由一系列节点（或称为元素）组成，每个节点包含数据和指向下一个节点的指针。在单向链表中，每个节点只能向前遍历，不能向后。 1. ...
数据结构实验报告.docx
11-12
实验内容3将随机数按奇偶性分组并压入栈，展示了堆栈在数据分类中的作用。实验内容4模拟了病人就诊的过程，使用队列来模拟等待队列，体现了队列的实际应用。 通过这些实验，学生不仅能掌握C语言编程技能，还能深入...
大三教师用数据结构实验报告
04-20
在这个大三教师用的数据结构实验报告中，主要涉及了两个重要的数据结构概念：顺序表和链表，并展示了它们的一些基本操作。 首先，我们来看顺序表的实验内容。顺序表是一种线性结构，它的元素在内存中是连续存放的。...
单链表操作2-单链表A拆分成奇数和偶数值单链表B和C(个人学习笔记，仅供参考)
m0_52378185的博客
03-17 2399
在一个带头结点的单链表A中，头指针为a，设计算法SplitList ( )将A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值为奇数的结点， 而C表的结点为A表中值为偶数的结点（链表A的元素类型为整型，要求B、C表除了头结点可以新开辟空间外，其余结点均利用A表的结点，不得申请新的结点空间）最后要求遍历B，C链表。
链表的奇偶排序
anbinxi5336的博客
01-07 544
将级数位的排在前面，偶数位的排到后面，。 利用两个指针，可以完成这个。 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */cla...
奇偶链表的分割
m0_69021942的博客
05-02 1178
奇偶链表的分割
对单链表分割为奇偶有序链表
Rankir的博客
03-15 4674
原理： ①对原链表中数据进行奇偶分布，奇数在前偶数在后 ②对原链表进行遍历，直至遍历至偶数，进行分割 ③对分割后的链表进行排序/头插法建立带头结点的单链表函数/ LinkList *Create_LinkListF( ) { elemtype ix; LinkList *head, *p; head = (LinkList *) malloc (sizeo
单链表之奇偶元素分开（保持奇偶数的原有顺序不变）
qq_40659154的博客
07-21 1492
typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; void segregate(LinkList &L){ LinkList r, p, oldEnd; //链表最后一个结点, 链表结点的替代结点 int flag=0; r = L->next; p = L; // r定位到链表的最后一个结点 while(r->next){ r = r->next; } oldEnd
Leetcode 题解 - 链表-(10)-链表元素按奇偶聚集
qq_40320556的博客
06-18 350
[LeetCode] Odd Even Linked List 奇偶链表 Given a singly linked list, group all odd nodes together followed by the even nodes. Please note here we are talking about the node number and not the value in...
js 实现数组数字奇偶归类
weixin_30437847的博客
05-04 477
如：[1,2,3,4,5,6,7,8] =>[1,7,3,5,4,6,2,8]，讲奇数放在数组前面部分，偶数放在数组后面部分。 实现方法一： var a = [1,2,3,4,5,6,7,8]; a.sort(function(x){ if(x % 2 === 0) return 1; }); 实现方法二： var a = [1,2,3,4,5,6,...
链表相关（基本操作+翻转链表+奇偶分类+回文链表判断）
kiss_the_rian的博客
08-31 192
链表基本操作 创建链表 头节点只有next 数据域无内容，一开始赋值给pre 有一个pre，用来连接新生成的节点 用new生成新节点 每次循环更新当前节点为pre节点 #include<vector> #include<iostream> using namespace std; struct node { int data; node* next; }; //创建链表 node* create(vector<int> &arr) { node *p
神经网络实践项目——数字奇偶识别
weixin_45735242的博客
08-02 2005
项目：奇偶识别 将一个int型整数转化为32位二进制数作为BP人工神经网络的输入（例如，整数2为10前面加30个0，这32个数字分别为32个输入），0或1作为输出层的输出（该数为偶数，则预期输出d为0；该数为奇数，则预期输出d为1），以这样的模型（32个输入，隐含层16个神经元，输出层1个神经元，学习率参数r的值为0.1）训练1000个回合（训练一回合=训练一次训练集，训练一回合后，打乱训练集，再进行下一回合的训练），然后对测试集进行测试并统计奇偶识别率。 训练集：1000个随机整数和1000个预期输出 测
二年级下学期算法实验报告汇总
资源摘要信息: "该文档是一份关于算法设计与分析的实验报告，为东北林业大学大二下学期的学生所撰写，记录了四次算法实验的内容与分析。" 在计算机科学与技术领域中，算法设计与分析是极其重要的核心课程。它关注于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值