高分求做c语言作业，急急急

// SET.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
// SET.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
/*
*2012年4月10日21:17:33
*功能:集合
*说明:默认第一个节点[下标为0],作为垃圾回收头节点，所以任何指向第一个节点[下标为0]，都认为指向结束
* 我就不认真写算法了，具体要改进的话，你在我的这个框架下很容易改的
*/
#define ARG_SETADT_SIZE 255

//函数声明
//初始化
bool SetNew(struct arg_SetADT*const pthis);

//测试函数
bool SetIN_SET(struct arg_SetADT*const pthis, int m_data);

//输入并插入到单链表中的函数
bool SetINSERT_SET(struct arg_SetADT*const pthis, int m_data);

//集合元素输出函数
void SetPrint(struct arg_SetADT*const pthis);

//获取第一个数据
bool SetGetFirstData(struct arg_SetADT*const pthis, int *const pm_data);

//获取下一个数据
bool SetGetNextData(struct arg_SetADT*const pthis, int *const pm_data);

//集合A、B的交C=A∩B的函数
bool SetMixed(struct arg_SetADT*const pthis, struct arg_SetADT*const pA, struct arg_SetADT*const pB);

//集合A、B的并D=A∪B的函数
bool SetAnd(struct arg_SetADT*const pthis, struct arg_SetADT*const pA, struct arg_SetADT*const pB);

//销毁
void SetDestroy(struct arg_SetADT*const pthis);

//节点
typedef struct arg_SetParADT
{
int m_index; //索引
int m_data; //数据
int m_point; //指针
}arg_SetParCDT, *parg_SetParCDT;

//集合对象
typedef struct arg_SetADT
{
//数据

//数据链
arg_SetParCDT sz_List[ARG_SETADT_SIZE];

//头节点索引
int m_Index;

//数据个数
int m_Length;

//处理函数

//初始化
bool (*New)(struct arg_SetADT*const pthis);

//测试函数
bool (*IN_SET)(struct arg_SetADT*const pthis, int m_data);

//输入并插入到单链表中的函数
bool (*INSERT_SET)(struct arg_SetADT*const pthis, int m_data);

//集合元素输出函数
void (*Print)(struct arg_SetADT*const pthis);

//获取第一个数据
bool (*GetFirstData)(struct arg_SetADT*const pthis, int *const pm_data);

//获取下一个数据
bool (*GetNextData)(struct arg_SetADT*const pthis, int *const pm_data);

//集合A、B的交C=A∩B的函数
bool (*Mixed)(struct arg_SetADT*const pthis, struct arg_SetADT*const pA, struct arg_SetADT*const pB);

//集合A、B的并D=A∪B的函数
bool (*And)(struct arg_SetADT*const pthis, struct arg_SetADT*const pA, struct arg_SetADT*const pB);

//销毁
void (*Destroy)(struct arg_SetADT*const pthis);

}arg_SetCDT, *parg_SetCDT;

//初始化
bool SetNew(const parg_SetCDT pthis)
{
//断言有初始化
assert(NULL != pthis->New);

int m_temp = 0;

//数据初始化
pthis->m_Length = 0;
pthis->m_Index = 0;

//
pthis->sz_List[0].m_index = -1;

//建立垃圾回收机制
pthis->sz_List[0].m_point = 1;

for (m_temp = 1; m_temp < ARG_SETADT_SIZE; m_temp++)
{
//垃圾池中可用节点个数
pthis->sz_List[0].m_data++;
pthis->sz_List[m_temp].m_index = m_temp;
//指针指向下一个节点
pthis->sz_List[m_temp].m_point = m_temp + 1;
}

//没有节点指向
pthis->sz_List[m_temp].m_point = 0;

//函数绑定
pthis->New = SetNew;

pthis->IN_SET = SetIN_SET;

pthis->INSERT_SET = SetINSERT_SET;

pthis->Print = SetPrint;

pthis->GetFirstData = SetGetFirstData;

pthis->GetNextData = SetGetNextData;

pthis->Mixed = SetMixed;

pthis->And = SetAnd;

pthis->Destroy = SetDestroy;

return true;
}

//测试函数(我这里快点写，就简单处理了)
bool SetIN_SET(struct arg_SetADT*const pthis, int m_data)
{
int m_temp = 0;
//没有数据
if (pthis->m_Length == 0)
{
return false;
}
for (m_temp = 1; m_temp < ARG_SETADT_SIZE; m_temp++)
{
if (0 == pthis->sz_List[m_temp].m_point)
{
continue;
}
//比对数据
if (m_data == pthis->sz_List[m_temp].m_data)
{
return true;
}

}

return false;
}

//输入并插入到单链表中的函数
bool SetINSERT_SET(const parg_SetCDT pthis, int m_data)
{
int m_point = 0;

//查看垃圾池中是否还有节点
if (0 == pthis->sz_List[0].m_data)
{
return false;
}
//从垃圾池中获取节点
m_point = pthis->sz_List[0].m_point;
pthis->sz_List[0].m_point = pthis->sz_List[m_point].m_point;
pthis->sz_List[0].m_data--;

//校验数据
assert(m_point);

//数据赋值 插入数据
pthis->sz_List[m_point].m_data = m_data;
pthis->sz_List[m_point].m_point = pthis->m_Index;
pthis->m_Index = m_point;

pthis->m_Length++;
return true;
}

//集合元素输出函数
void SetPrint(const parg_SetCDT pthis)
{
int m_temp = 0;
int m_point = pthis->m_Index;

for (m_temp = 0; m_temp < pthis->m_Length; m_temp++)
{
printf("第%d个数据:%d\n",m_temp+1, pthis->sz_List[m_point].m_data);
m_point = pthis->sz_List[m_point].m_point;
//assert(m_point);
}
}

//获取第一个数据
bool SetGetFirstData(struct arg_SetADT*const pthis, int *const pm_data)
{
if (0 == pthis->m_Length)
{
return false;
}

*pm_data = pthis->sz_List[pthis->m_Index].m_data;
//第一个[下标为0]的索引号作为数据移动的记录点
pthis->sz_List[0].m_index = pthis->sz_List[pthis->m_Index].m_point;
return true;
}

//获取下一个数据
bool SetGetNextData(struct arg_SetADT*const pthis, int *const pm_data)
{
//ole自治
if (-1 == pthis->sz_List[0].m_index)
{
return pthis->GetFirstData(pthis, pm_data);
}

if (0 == pthis->sz_List[0].m_index)
{
return false;
}

*pm_data = pthis->sz_List[pthis->sz_List[0].m_index].m_data;
//第一个[下标为0]的索引号作为数据移动的记录点
pthis->sz_List[0].m_index = pthis->sz_List[pthis->sz_List[0].m_index].m_point;
return true;
}

//集合A、B的交C=A∩B的函数
bool SetMixed(struct arg_SetADT*const pthis, struct arg_SetADT*const pA, struct arg_SetADT*const pB)
{
int m_data = 0;
int m_temp = 0;

//如果C中本身有数据
if (0 != pthis->m_Length)
{
return false;
}
//A B都有
if( pA->GetFirstData(pA, &m_data) ){
//检测数据是否在B
if (pB->IN_SET(pB, m_data))
{
pthis->INSERT_SET(pthis, m_data);
}
}else{
return false;
}

for (m_temp = 1; m_temp < pA->m_Length; m_temp++)
{
if( pA->GetNextData(pA, &m_data) ){
//检测数据是否在B
if (pB->IN_SET(pB, m_data))
{
pthis->INSERT_SET(pthis, m_data);
}
}else{
return true;
}
}

return true;
}

//集合A、B的并D=A∪B的函数
bool SetAnd(struct arg_SetADT*const pthis, struct arg_SetADT*const pA, struct arg_SetADT*const pB)
{
int m_data = 0;
int m_temp = 0;
int m_temp1st = 0;
int m_temp2st = 0;

//查看A和B的交是否会超过缓冲(简单检测,不准确)
if (pB->m_Length + pA->m_Length >= ARG_SETADT_SIZE)
{
return false;
}

if( pA->GetFirstData(pA, &m_data) ){
pthis->INSERT_SET(pthis, m_data);
}else{
//copy操作 直接copy pB
if( pB->GetFirstData(pB, &m_data) ){
pthis->INSERT_SET(pthis, m_data);
}else{
return true;
}

for (m_temp = 1; m_temp < pA->m_Length; m_temp++)
{
if( pB->GetNextData(pB, &m_data) ){
pthis->INSERT_SET(pthis, m_data);
}else{
return true;
}
}
}

for (m_temp1st = 1; m_temp1st < pA->m_Length; m_temp1st++)
{
if( pA->GetNextData(pA, &m_data) ){
pthis->INSERT_SET(pthis, m_data);
}
}

//获取pB
if( pB->GetFirstData(pB, &m_data) ){
//检测数据是否在A
if (!pA->IN_SET(pA, m_data))
{
pthis->INSERT_SET(pthis, m_data);
}
}else{
return true;
}

for (m_temp2st = 1; m_temp2st < pA->m_Length; m_temp2st++)
{
if( pB->GetNextData(pB, &m_data) ){
//检测数据是否在B
if (!pA->IN_SET(pA, m_data))
{
pthis->INSERT_SET(pthis, m_data);
}
}else{
return true;
}
}

return true;
}

//销毁
void SetDestroy(const parg_SetCDT pthis)
{
//因为没有申请内存，所以直接清除数据即可
pthis->m_Length = 0;
memset(pthis->sz_List, 0, sizeof(arg_SetParCDT)*ARG_SETADT_SIZE);

//解除函数绑定
pthis->New = NULL;

pthis->IN_SET = NULL;

pthis->INSERT_SET = NULL;

pthis->Print = NULL;

pthis->GetFirstData = NULL;

pthis->GetNextData = NULL;

pthis->Mixed = NULL;

pthis->And = NULL;

pthis->Destroy = NULL;
}

int main(int argc, char* argv[])
{
arg_SetCDT A;
arg_SetCDT B;
arg_SetCDT C;
arg_SetCDT D;

A.New = SetNew;
A.New(&A);

B.New = SetNew;
B.New(&B);

C.New = SetNew;
C.New(&C);

D.New = SetNew;
D.New(&D);

A.INSERT_SET(&A, 40);
A.INSERT_SET(&A, 10);
A.INSERT_SET(&A, 55);
A.INSERT_SET(&A, 45);
A.INSERT_SET(&A, 52);
A.INSERT_SET(&A, 51);
A.INSERT_SET(&A, 35);
printf("\nA\n");
A.Print(&A);

B.INSERT_SET(&B, 32);
B.INSERT_SET(&B, 12);
B.INSERT_SET(&B, 61);
B.INSERT_SET(&B, 45);
B.INSERT_SET(&B, 31);
B.INSERT_SET(&B, 36);
B.INSERT_SET(&B, 24);
printf("\nB\n");
B.Print(&B);

printf("\n AND \n");
C.And(&C, &A, &B);
C.Print(&C);

printf("\n MIXED \n");
D.Mixed(&D, &A, &B);
D.Print(&D);

A.Destroy(&A);
B.Destroy(&B);
C.Destroy(&C);
D.Destroy(&D);

return 0;
}

//楼主，我为了帮你做这个题，花了我差不多2个多小时的时间，你自己看着办吧
//VC6.0 测试通过

求出这个数列的前20项之和。要C语言的问题补充：这个是一整道题 #include #include #include int i,j=0,choice,ZQddaU

高端问题