第1关：有序单链表的插入操作
任务描述
本关任务：已知带头结点的单链表中的元素以值递增有序排列，要求实现一个算法，在单链表中插入一个新整数，并保持该单链表仍然以值递增有序。
相关知识
单链表结点类型定义如下：
typedef struct LNode // 结点类型定义
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode,*LinkList; // LinkList为结构指针类型
为了令算法具有通用性，使其尽可能地适用于各种可能的场合，将要处理的数据类型加以抽象，使其适用于不同类型的数据，是提高代码通用性的重要手段。
单链表中数据类型ElemType可以多种多样，但是在编程实现算法时针对不同数据类型，每类数据元素的输入输出是有区别的，单链表的基本操作算法要在计算机上执行，须针对ElemType类型数据编写输入、输出、比较等函数。
ElemType类型根据实际问题需要灵活定义，但是在编程实现算法时针对不同数据类型，数据元素的输入输出是有区别的，单链表的基本操作算法要在计算机上执行，须针对ElemType类型数据编写输入、输出、比较是否相等、比较大小等函数：
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
int compare(ElemType a,ElemType b);
ElemType类型根据实际问题需要灵活定义，如果ElemType类型是结构体类型，结构体变量之间整体是不可以比较大小的，结构体变量之间只能比较某个成员的大小；比较两个结构体变量是否相等与比较两个结构体变量某个成员的大小也是有区别的。
在有序单链表中插入新的结点，算法的关键问题：
首先必须维护当前结点的前指针，
然后还要维护要插入的位置的前后指针，
每个要插入的结点都要从头开始比较。
编程要求
根据提示，在右侧编辑器 Begin-End 区间补充代码，完成单链表按照值的大小插入函数的定义，具体要求如下：
int ListSortInsert(LinkList &L,ElemType e,int(*compare)(ElemType, ElemType) ); //带头结点的单链表L，其结点存储的数据是递增有序的，将e插入L，并保持该单链表的有序性
说明：
用函数指针compare来实现对ElemType类型数据元素的比较大小的函数的调用。
首先创建带头结点的空单链表，反复调用本函数，构造一个有序单链表。
测试说明
平台会对你编写的代码进行测试：
测试输入：
5
12 47 5 8 69
预期输出：
5 8 12 47 69
输入说明
第一行输入单链表的数据元素的个数N；
第二行输入单链表N个无序的整数。
输出说明
第一行输出递增的有序单链表。
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
/* 定义ElemType为int类型 */
typedef int ElemType;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
int comp(ElemType a,ElemType b);
/* 单链表类型定义 */
typedef struct LNnode
{
ElemType data;
struct LNnode *next;
}LNnode,*LinkList;
void InitList(LinkList &L);
int ListSortInsert (LinkList &L, ElemType e,int (*compare)(ElemType,ElemType));
void ListTraverse(LinkList L,void(*vi)(ElemType));
int main() //main() function
{
LinkList A;
ElemType e;
InitList(A);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListSortInsert(A, e,comp);
}
ListTraverse(A,output) ;
return 0;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
int comp(ElemType a,ElemType b)
{
if(a>b)
return 1;
else
if(a<b)
return -1;
else
return 0;
}
/*****单链表的基本操作*****/
void InitList(LinkList &L)
{
// 操作结果：构造一个空的单链表L
/********** Begin **********/
L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
if(!L) // 存储分配失败
return ;
L->next=NULL; // 指针域为空
/********** End **********/
}
void ListTraverse(LinkList L,void(*vi)(ElemType))
{
// 初始条件：单链表L已存在。
//操作结果：依次对L的每个数据元素调用函数vi()
/********** Begin **********/
LinkList p=L->next;
while(p)
{
vi(p->data);
p=p->next;
}
printf("\n");
/********** End **********/
}
int ListSortInsert (LinkList &L, ElemType e,int (*compare)(ElemType,ElemType))
{
/********** Begin **********/
LNnode *m=(LNnode*)malloc(sizeof(LNnode));
LinkList q,p=L;
if(m==NULL)
return false;
m->data=e;
m->next=NULL;
q=L->next;
if(q==NULL)
{
L->next=m;
return true;
}
while(q)
{
if(comp(e,q->data)==-1)
{
m->next=p->next;
p->next=m;
return true;
}
else
{
p=q;
q=q->next;
}
}
p->next=m;
return 0;
/********** End **********/
}
第2关：有序单链表中值相同的多余结点的删除操作
任务描述
本关任务：已知单链表中的元素以值递增有序排列，试写一高效的算法，删除表中所有值相同的多余元素，使得操作后的单链表中所有元素的值均不相同，同时释放被删结点空间，例如初始单链表为：（1 2 2 2 3 3 4 4 4 4 5 6 6） ，执行删除算法后单链表为：（1 2 3 4 5 6）。
相关知识
单链表结点类型定义如下：
typedef struct LNode // 结点类型定义
{
ElemType data; //数据域
struct LNode *next; //指针域
}LNode,*LinkList; // LinkList为结构指针类型
typedef int ElemType;
数据元素的类型ElemType为int类型。
在有序单链表中删除重复的结点，重复的元素必然相邻，删除算法的关键步骤如下：
只要单链表不为空，定义3个结点指针：ppre、pcur、pdel。pcur作为活动指针，初始指向第一个数据元素的结点，而ppre初始指向pcur的前驱结点，pdel用于指向待删除的结点。
用一个循环控制ppre和pcur向后移动，当ppre指向的结点值和pcur指向的结点值相等，那么ppre的指向的位置保持不动，将pcur的指向先传递给pdel，然后pcur向后移一个位置，再将ppre指向的结点作为pcur指向的结点的前驱，这两个结点再次保持相邻，最后释放pdel指向结点的空间，达到删除多余结点的效果。如果后面还有和ppre指向的结点值相同的结点，便通过循环重复执行这些操作。循环执行的过程中ppre就相当于一个基准，不会发生移动。只有当ppre指向的结点值和此时pcur指向的结点值不相等时，ppre才会向后移动一个位置，再将pcur指向ppre指向位置的下一个位置。
编程要求
根据提示，在右侧编辑器 Begin-End 区间补充代码，完成单链表按照值的大小插入函数的定义，具体要求如下：
int ListSortInsert(LinkList &L,ElemType e,int(*compare)(ElemType, ElemType) ); //带头结点的单链表L，其结点存储的数据是递增有序的，将e插入L，并保持该单链表的有序性
说明：
用函数指针equals来实现调用判断ElemType类型数据元素是否相等的函数。
用函数指针compare来实现调用ElemType类型数据元素进行比较大小的函数。
调用本函数将一个有重复数据的有序单链表，改造成所有元素的值均不相同的有序单链表。
测试说明
平台会对你编写的代码进行测试：
测试输入：
14
1 1 2 2 2 3 3 4 4 4 4 5 6 6
预期输出：
1 1 2 2 2 3 3 4 4 4 4 5 6 6
1 2 3 4 5 6
输入说明
第一行输入有序单链表的数据元素的个数N；
第二行输入N个有序有重复值的整数。
输出说明
第一行输出初始的有重复值的有序单链表；
第二行输出所有元素的值均不相同的有序单链表。
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
/* 定义ElemType为int类型 */
typedef int ElemType;
/* 单链表类型定义 */
typedef struct LNnode
{
ElemType data;
struct LNnode *next;
}LNnode,*LinkList;
void input(ElemType &s);
void output(ElemType s);
int equals(ElemType a,ElemType b);
int comp(ElemType a,ElemType b);
void InitList(LinkList &L);
int ListSortInsert (LinkList &L, ElemType e,int (*compare)(ElemType,ElemType));
void ListTraverse(LinkList L,void(*vi)(ElemType));
void ListDeleteSameNode(LinkList &L,int (*equals)(ElemType,ElemType));
int main() //main() function
{
LinkList A;
ElemType e;
InitList(A);
int n,i;
// cout<<"Please input the list number ";
cin>>n;
for(i=1;i<=n;i++)
{
cin>>e;
ListSortInsert(A, e,comp);
}
ListTraverse(A,output) ;
ListDeleteSameNode(A, equals);
ListTraverse(A,output) ;
return 0;
}
/*****ElemType类型元素的基本操作*****/
void input(ElemType &s)
{
cin>>s;
}
void output(ElemType s)
{
cout<<s<<" ";
}
int equals(ElemType a,ElemType b)
{
if(a==b)
return 1;
else
return 0;
}
int comp(ElemType a,ElemType b)
{
if(a>b)
return 1;
else
if(a<b)
return -1;
else
return 0;
}
/*****单链表的基本操作*****/
void InitList(LinkList &L)
{
// 操作结果：构造一个空的单链表L
/********** Begin **********/
L=(LinkList)malloc(sizeof(LNnode)); // 产生头结点，并使L指向此头结点
if(!L) // 存储分配失败
return ;
L->next=NULL; // 指针域为空
/********** End **********/
}
void ListTraverse(LinkList L,void(*vi)(ElemType))
{
// 初始条件：单链表L已存在。
//操作结果：依次对L的每个数据元素调用函数vi()
/********** Begin **********/
LinkList p=L->next;
while(p)
{
vi(p->data);
p=p->next;
}
printf("\n");
/********** End **********/
}
int ListSortInsert (LinkList &L, ElemType e,int (*compare)(ElemType,ElemType))
{ // 在带头结点的有序单链线性表L中插入元素e后仍然有序
/********** Begin **********/
LNnode *curPtr ,*prePtr;
int flag = 0;//检测是否成功插入；
LNnode *insPtr = (LNnode *)malloc(sizeof(LNnode));
if(!insPtr) // 存储分配失败
return 0;
insPtr->data = e;
curPtr = L->next;
prePtr = L;
while(curPtr)
{
if(compare(curPtr->data, insPtr->data) > 0 )
{
prePtr->next = insPtr;
insPtr->next = curPtr;
flag = 1;
break;
}
else
{
curPtr = curPtr->next;
prePtr = prePtr->next;
}
}
if(flag == 0)
{
prePtr->next = insPtr;
insPtr->next = NULL;
}
return 1;
/********** End **********/
}
void ListDeleteSameNode(LinkList &L,int (*equals)(ElemType,ElemType) )
{ // 在带头结点的有序单链线性表L中删除值相同的多余结点
/********** Begin **********/
LinkList m,n,p=L;
while(p!=NULL)
{
m=p;
p=p->next;
if(p)
{
if(equals(m->data,p->data))
{
m->next=p->next;
n=p;
p=m;
}
}
}
/********** End **********/
}
4331
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
