骑士游历数据结构课程设计

Ⅰ 数据结构课程设计：设有n个人围坐在一个圆桌周围，编号为1,2,…,n。现在从第s个人开始逆序报数，即：第s个

= =···你现在还要代码么····我刚刚码完的题····不过我只用了循环单链表

Ⅱ 《数据结构》课程设计题目急急！！！！

又来了
这个是学生的管理的 改改吧
#include<iostream.h>
#include"string.h"
#include "process.h"
#include <stdio.h>
struct Node
{
int age;
char* name;
Node* next;

};
struct newnode
{
char newname[20];
int newage;

};
void AddTohead(Node* node,char* name,int age)
{
if(!node)
return;
Node* newnode = new Node;
if(name)
{
int cd = strlen(name)+1;
newnode->name = new char [cd];
strcpy(newnode->name,name);
}
else newnode->name = NULL;
newnode->age = age;
newnode->next = node->next;
node->next = newnode;

}
void Show(Node* node)
{
Node* p = NULL;

p = node->next;
while(p!=NULL&&p->name!=NULL)//我的软肋 我没有注意指针的真正的指向 以后要注意 这是我看以前的程序中看出来的问题 while(p)这是我原先写 切记切记
{ //看完程序后我还是没写对 我写对了
cout<<p->name<<" "<<p->age<<endl;

p = p->next;

}

}
void Delete(Node* node)
{
Node* del;
while(node->next)
{
del = node->next;
if(del->next)
delete [] del->name;
node->next = del->next;
delete del;

}

}
void AddToList(Node* node,char* name,int age)
{
if(!node)
return;
Node* newnode = new Node;
while(node->next)
node = node->next;
if(name)
{
int cd = strlen(name)+1;
newnode->name = new char [cd];
strcpy(newnode->name,name);
}
else newnode->name = NULL;
newnode->age = age;
node->next = newnode;
newnode->next = NULL;

}
void FindAndAdd(Node* node,char* findname,char* addname,int addage,int canshu)
{
if(!node)
return;
Node* head = node;
Node* m = NULL;
m = node->next;
do
{
if (!strcmp(m->name,findname))
break;
m = m->next;
} while (m);

if(m==NULL)
{
cout<<"nobody"<<endl;
}
else
{
switch(canshu)
{
case 1:
{
Node* p = head;
while(p->next!= m )
{
p = p->next;
}
Node* newnode = new Node;
if(addname)
{
int cd = strlen(addname)+1;
newnode->name = new char [cd];
strcpy(newnode->name,addname);
}
else
{
newnode->name = new char;
strcpy(newnode->name,"somebody");
}
newnode->age = addage;
newnode->next = p->next;
p->next = newnode;

} break;
case 2:
{
Node* newnode = new Node;
if(addname)
{
int cd = strlen(addname)+1;
newnode->name = new char [cd];
strcpy(newnode->name,addname);

}
else
{
newnode->name = new char;
strcpy(newnode->name,"somebody");
}
newnode->age = addage;
newnode->next = m->next;
m->next = newnode;

} break;
default:break;
}

}

}
void DelSomeBody(Node* node,char* name)
{
if(!node)
return;
Node* head = node;
if(!name)
cout<<"the name please";
else
{
Node* p = node->next;
Node* m = node;
while(m)
{
if(!strcmp(p->name,name))
break;
m = m->next;
p = p->next;
}
if(p==NULL)
{
cout<<"no one";
}
else
{
while(head->next!= p)
head = head->next;
delete [] p->name;
head->next = p->next;
delete p;

}
}
}

void Change(Node* node,char* name,char* newname,int age)
{
if(!node)
return;
Node* head = node;
if(!name)
cout<<"the name please";
else
{
Node* p = node->next;
Node* m = node;
while(m)
{
if(!strcmp(p->name,name))
break;
m = m->next;
p = p->next;
}
if(p==NULL)
{
cout<<"no one";
}
else
{
int cd = strlen(newname)+1;
p->name = new char [cd];

strcpy(p->name,newname);
p->age = age;
}

}

}
void Find(Node* node,char* findname)
{

if(!node)
return;
Node* head = node;
Node* m = NULL;
m = node->next;
if(!m)
cout<<"链表为空的 不存在 请选择操作"<<endl;
return;
do
{
if (!strcmp(m->name,findname))
break;
m = m->next;
} while (m);

if(m==NULL)
{
cout<<"nobody"<<endl;
}
else
{
cout<<m->name<<"的年龄是"<<m->age<<endl;

}

}

void CleanTheWindow()
{
system("cls");
}

void Keep(Node* node,char* fname)
{
Node* p = node->next;
newnode newd;
FILE* ip = fopen(fname,"wb");
if(!ip)
{
cout<<"wrong"<<endl;
return;
}
while(p)
{
strcpy(newd.newname,p->name);
newd.newage = p->age;
fwrite(&newd,sizeof(newnode),1,ip);
p = p->next;

}
fclose(ip);
}
void CreatList(Node* node,char* fname)
{
newnode newd;
FILE* ip =fopen(fname,"rb");
if(!ip)
{
cout<<"wrong"<<endl;
return;
}
Delete(node);
while(!feof(ip))
{
int a =fread(&newd,sizeof(newnode),1,ip);
if(a==1)
AddTohead(node,newd.newname,newd.newage);

}
fclose(ip);

}

void main()
{
Node node;
node.age = NULL;
node.name = NULL;
node.next = NULL;

while(1)

{
cout<<"请选择您的操作1：添加到头部（输入姓名，年龄）"<<endl;
cout<<" 2：添加到尾部（输入姓名，年龄）"<<endl;
cout<<" 3：查找某人的年龄 "<<endl;
cout<<" 4：在某人的前面或后面插入"<<endl;
cout<<" （输入查找的姓名，输入要插入的名字，输入要插入的名字，和年龄）"<<endl;
cout<<" (输入插入类型1：在前插入 2：在后插入)"<<endl;
cout<<" 5：修改某人的信息（输入要修改人的名字 输入要修改的信息姓名，年龄）"<<endl;
cout<<" 6：删除某人的信息（输入你要删除的人的姓名）"<<endl;
cout<<" 7：删除链表"<<endl;
cout<<" 8：显示"<<endl;
cout<<" 9：清屏"<<endl;
cout<<" 10：保存"<<endl;
cout<<" 11：显示保存的内容"<<endl;
cout<<" 0：退出"<<endl;
int a;
cin>>a;//如何对输入的数据进行判断，比如我输入adfd字符型的时候，我想提示用户输入错误

switch(a)
{
case 1:
{
cout<<"请输入要加在头部的姓名和年龄"<<endl;
char* name = new char;
int age;
cin>>name;
cin>>age;
AddTohead(&node,name,age);
cout<<"加入头部完成 请选择下一步操作"<<endl;
} break;
case 2:
{
cout<<"请输入要加在尾部的姓名和年龄"<<endl;
char* name = new char;
int age;
cin>>name;
cin>>age;
AddToList(&node,name,age);
cout<<"加入尾部完成 请选择下一步操作"<<endl;
} break;
case 3:
{
cout<<"请输入要查找人的姓名"<<endl;
char* name = new char;
cin>>name;
Find(&node,name);
} break;
case 4:
{
cout<<"请按上面的输入"<<endl;
char* name = new char;
char* name2 = new char;
int age;
int cs;
cin>>name;
cin>>name2;
cin>>age;
cin>>cs;
FindAndAdd(&node,name,name2,age,cs);
cout<<"4输入完成"<<endl;

} break;
case 5:
{
cout<<"输入要修改的信息和修改的信息"<<endl;
char* name = new char;
char* name2 = new char;
int age;
cin>>name;
cin>>name2;
cin>>age;
Change(&node,name,name2,age);
cout<<"修改完成"<<endl;

} break;
case 6:
{
cout<<"输入要删除的姓名"<<endl;
char* name = new char;
cin>>name;
DelSomeBody(&node,name);
cout<<"删除完成"<<endl;
} break;
case 7:
{
cout<<"确定要删除全部的链表吗？1 是 2否"<<endl;
int npd;
cin>>npd;
if(npd==1)
{
Delete(&node);
}
else break;
} break;
case 8:
{
cout<<"当前的链表是"<<endl;
Show(&node);
} break;
case 9:
{
CleanTheWindow();
} break;
case 10:
{
cout<<"请输入要保存的文件的名称"<<endl;
char a[10];
cin>>a;
Keep(&node,a);
}
break;
case 11:
{
cout<<"请输入保存的文件的名称"<<endl;
char a[10];
cin>>a;
CreatList(&node,a);
Show(&node);
}
break;
case 0:
{
goto stop;

} break;
default :cout<<"输入有误重新输入"<<endl;

}
}

stop: cout<<"exit"<<endl;

}
其实我也很菜的

Ⅲ 求大神帮忙写个程序：数据结构课程设计的题目 题目见补充处 希望大神们帮忙，拜托拜托~~

给你其实是在害你，给你知识点，如果还不会再来问我
线性代数的学习切入点：线性方程组。换言之，可以把线性代数看作是在研究线性方程组这一对象的过程中建立起来的学科。
线性方程组的特点：方程是未知数的一次齐次式，方程组的数目s和未知数的个数n可以相同，也可以不同。
关于线性方程组的解，有三个问题值得讨论：
（1）、方程组是否有解，即解的存在性问题；
（2）、方程组如何求解，有多少个解；
（3）、方程组有不止一个解时，这些不同的解之间有无内在联系，即解的结构问题。
高斯消元法，最基础和最直接的求解线性方程组的方法，其中涉及到三种对方程的同解变换：
（1）、把某个方程的k倍加到另外一个方程上去；
（2）、交换某两个方程的位置；
（3）、用某个常数k乘以某个方程。我们把这三种变换统称为线性方程组的初等变换。
任意的线性方程组都可以通过初等变换化为阶梯形方程组。
由具体例子可看出，化为阶梯形方程组后，就可以依次解出每个未知数的值，从而求得方程组的解。
对方程组的解起决定性作用的是未知数的系数及其相对位置，所以可以把方程组的所有系数及常数项按原来的位置提取出来，形成一张表，通过研究这张表，就可以判断解的情况。我们把这样一张由若干个数按某种方式构成的表称为矩阵。
可以用矩阵的形式来表示一个线性方程组，这至少在书写和表达上都更加简洁。
系数矩阵和增广矩阵。
高斯消元法中对线性方程组的初等变换，就对应的是矩阵的初等行变换。阶梯形方程组，对应的是阶梯形矩阵。换言之，任意的线性方程组，都可以通过对其增广矩阵做初等行变换化为阶梯形矩阵，求得解。
阶梯形矩阵的特点：左下方的元素全为零，每一行的第一个不为零的元素称为该行的主元。
对不同的线性方程组的具体求解结果进行归纳总结（有唯一解、无解、有无穷多解），再经过严格证明，可得到关于线性方程组解的判别定理：首先是通过初等变换将方程组化为阶梯形，若得到的阶梯形方程组中出现0=d这一项，则方程组无解，若未出现0=d一项，则方程组有解；在方程组有解的情况下，若阶梯形的非零行数目r等于未知量数目n，方程组有唯一解，若r在利用初等变换得到阶梯型后，还可进一步得到最简形，使用最简形，最简形的特点是主元上方的元素也全为零，这对于求解未知量的值更加方便，但代价是之前需要经过更多的初等变换。在求解过程中，选择阶梯形还是最简形，取决于个人习惯。
常数项全为零的线性方程称为齐次方程组，齐次方程组必有零解。
齐次方程组的方程组个数若小于未知量个数，则方程组一定有非零解。
利用高斯消元法和解的判别定理，以及能够回答前述的基本问题（1）解的存在性问题和（2）如何求解的问题，这是以线性方程组为出发点建立起来的最基本理论。
对于n个方程n个未知数的特殊情形，我们发现可以利用系数的某种组合来表示其解，这种按特定规则表示的系数组合称为一个线性方程组（或矩阵）的行列式。行列式的特点：有n！项，每项的符号由角标排列的逆序数决定，是一个数。
通过对行列式进行研究，得到了行列式具有的一些性质（如交换某两行其值反号、有两行对应成比例其值为零、可按行展开等等），这些性质都有助于我们更方便的计算行列式。
用系数行列式可以判断n个方程的n元线性方程组的解的情况，这就是克莱姆法则。
总而言之，可把行列式看作是为了研究方程数目与未知量数目相等的特殊情形时引出的一部分内容

Ⅳ 数据结构课程设计

这个是程序：
#include "string.h"
#define NULL 0
unsigned int key;
unsigned int key2;
int *p;
struct node
{
char name[20],address[20];
char num[11];
struct node *next;
}
**phone;
**nam;
**address;
typedef struct node *pnode;
typedef struct node *mingzi;

void hash(char num[11])
{
int i = 3;
key=(int)num[2];
while(num[i]!=NULL)
{
key+=(int)num[i];
i++;
key=key%17;

}

void hash2(char name[8])
{
int i = 1;
key2=(int)name[0];
while(name[i]!=NULL)
{
key2+=(int)name[i];
i++;
}
Key2=key2%17;

}

struct node* input()
{
struct node *temp=(struct node*)malloc(sizeof(struct node));
temp = new node;
temp->next=NULL;
printf("qing shu ru xing ming(no more then 8 chars) :\n");
scanf("%s",&temp->name);
printf"qing shu ru dian hua hao ma(no more then 11 numbers):\n");
scanf("%s",&temp->num);
printf("qing shu ru di (no more then 20 chars):\n");
scanf("%s",&temp->address);
return temp;
}

int add()
{
struct node *newphone;
struct node *newname;
newphone=input();
printf("ni de ji lu shi");
if(find(newphone->num))
{
printf("hao ma yi jing cun zai bu nene zai tian jia.\n");
return 0;
}
if(find2(newphone->name))
{
printf("xing ming yi jing cun zai bu neng zai tian jia.\n");
return 0;
}
printf("%s_%s_%s\n",newphone->name,newphone->address,newphone->num);
newname=newphone;
newphone->next=NULL;
newname->next=NULL;
hash(newphone->num);
hash2(newname->name);
newphone->next = phone[key]->next;
phone[key]->next=newphone;
newname->next = nam[key2]->next;
nam[key2]->next=newname;
return 0;
}

int find(char num[11])
{
int isfind=0;
struct node *q;
hash(num);
node *q=phone[key]->next;
while(q!= NULL)

{
if(strcmp(num,q->num) ==0)
{
isfind=1;
break;
}
q=q->next;
}
if(isfind)
printf("%s_%s_%s\n",q->name,q->address,q->num);
return isfind;
}
int find2(char name[8])
{
int isfind=0;
hash2(name);

struct node *q=nam[key2]->next;
while(q!= NULL)
{
if(strcmp(name,q->name)==0)
{
isfind=1;
break;
}
q=q->next;
}
if(isfind)
printf("%s_%s_%s\n",q->name,q->address,q->num);
return isfind;
}

void create()
{
int i;
phone = (pnode*)malloc(13*sizeof(pnode));
for(i=0;i<13;i++)
{
phone[i]=(struct node*)malloc(sizeof(struct node));
phone[i]->next=NULL;
}

}
void create2()
{
int i;
nam = (mingzi*)malloc(13*sizeof(mingzi));
for(i=0;i<13;i++)
{
nam[i]=(struct node*)malloc(sizeof(struct node));
nam[i]->next=NULL;
}
}
void list()
{
int i;
struct node *p;
for(i=0;i<13;i++)
{
p=phone[i]->next;
while(p)
{
printf("%s_%s_%s\n",p->name,p->address,p->num);
p=p->next;
}
}
}
void list2()
{
int i;
struct node *p;
for(i=0;i<13;i++)
{
p=nam[i]->next;
while(p!=NULL)
{
printf("%s_%s_%s\n",p->name,p->address,p->num);
p=p->next;
}
}
}

void menu()
{
printf("0.tian jia ji lv.\n");
printf("2.cha zhao ji lu.\n");
printf("3.xing ming lie biao.\n");
printf("4.hao ma lie biao.\n");
printf("5.qing chu suo you ji lu.\n");
printf("6.tui chu xi tong.\n");
}

int main()
{
char num[11];
char name[8];
int sel;
create();
create2();
while(1)
{
menu();
scanf("%d",&sel);
if(sel==3)
{
char b;
printf("Input 9 to search with number,8 to name.\n");
b=getch();
if(b=='9')
{
printf("Please input the number:\n");
scanf("%s",&num);

if(!find(num))
printf("Record not exist.\n");
}
else if(b=='8')
{
printf("Please input the name:\n");
scanf("%s",&name);
if(!find(name))
printf("Record not exist.\n");
}
else
{
printf("Wrong input!Please input again!\n");
continue;
}
}
else if(sel==2)
{
printf("All record with name:\n");
list2();

}
else if(sel==0)
{

printf("Please input the information:\n");
add();
}
else if(sel==4)
{

printf("All record with number:\n");
list();
}
else if(sel==5)
{
create();
create2();

printf("All records have been removed.\n");
}

else if(sel==6)
{printf("7");
break;
}
}
return 0;
}

Ⅳ 数据结构课程设计作业

的深度优先周游
void dfs(Graph g,Vertex v)
{
Vertex v1;
v.mark = TRUE;
for(v1=firstAdjacent(g,v); v1!= NULL; v1=nextAdjacent(g,v,v1))
dfs(g,v1);
}
void dft(Graph g)
{
Vertex v;
for(v=firstVertex(g); v!= NULL; v=nextVertex(g,v))
{
if(v.mark==FALSE)
dfs(g,v);
}
}
看一下能行吗，行的话我再把广度优先写上。

很多版啊非常的多权，不过我还是比较相信比较老的店铺了！！或者你有没有朋友在网上买过的,可以让他推荐下，我就是经常在同事推荐的淘西东好店买过很多东西，暂时没出现问题。时尚快购吧，就是这样的一个网站。里面有很多淘宝的高信用卖家。

Ⅵ 谁有数据结构课程设计集合交并运算啊

#include<iostream>
#include<cstdlib>
#include<cstdio>
using namespace std;

#define ElemType char

typedef struct ElemNode
{
ElemType elem;
struct ElemNode *next;
}ElemNode, *Set;

//-------------FunctionList------------------------------
//---------------函数原型--------------------------------
int LengthOf(Set src);//返回一个集合的长度
void CreateSet(Set dest);//创建一个新的字母集合，限定a-z
void EmptySet(Set dest);//清空一个集合，保留头结点
void DestroySet(Set dest);//销毁集合
void SortSet(Set dest);//对一个集合进行从小到大的排序
void DisplaySet(Set src);//打印集合的所有元素

int ExistElem(Set dest, ElemType e);//判断元素是否存在于集合中
void DelElem(Set dest, ElemType e);//删除集合中的一个元素一次
void AddElem(Set dest, ElemType e);//在链表尾部追加一个元素
void ContactSet(Set dest, Set src);//连接一个集合到另一个集合
void AddSet(Set dest, Set src1, Set src2);//集合并运算
void MulSet(Set dest, Set src1, Set src2);//集合交运算
void SubSet(Set dest, Set src1, Set src2);//集合差运算
int ExistSubset(Set dest, Set src);//子集判断
void NegSet(Set dest, Set src);//求补集

int main()
{
Set dest=(Set)malloc(sizeof(ElemNode));
Set src1=(Set)malloc(sizeof(ElemNode));
Set src2=(Set)malloc(sizeof(ElemNode));
dest->next=NULL;
cout<<"输入两个集合："<<endl;
CreateSet(src1);CreateSet(src2);
cout<<endl;
cout<<"Set1 = ";DisplaySet(src1);
cout<<"\t";
cout<<"Set2 = ";DisplaySet(src2);
cout<<endl<<endl;
int item;
cout<<"1->集合并"<<" "<<"2->集合交"<<" "<<"3->集合差"<<" "<<"非零整数->错误！重输"<<" "<<"0->进入下一步演示"<<endl;
while(cin>>item)
{
if(item)
switch(item)
{
case 1: cout<<"集合并运算：Set1∪Set2 = ";
AddSet(dest, src1, src2);
DisplaySet(dest);
EmptySet(dest);
cout<<endl;break;
case 2: cout<<"集合交运算：Set1∩Set2 = ";
MulSet(dest, src1, src2);
DisplaySet(dest);
EmptySet(dest);
cout<<endl;break;
case 3: cout<<"集合差运算：Set1-Set2 = ";
SubSet(dest, src1, src2);
DisplaySet(dest);
EmptySet(dest);
cout<<endl;break;
default: cout<<"输入错误！重输！！！"<<endl;break;

}
else {cout<<"进入下一步演示..."<<endl;break;} // 此处在VC++ 6.0 运行与CFree中有点不同（在CFree中要按下回车~~~）

}
getchar();
cout<<"输入一个集合："<<endl;
CreateSet(dest);
cout<<"原集合为：";
DisplaySet(dest);
cout<<endl<<endl;
char ch;
cout<<"在链表尾部添加一个元素ch = ";
cin>>ch;
AddElem(dest, ch);
DisplaySet(dest);
cout<<endl<<endl;
cout<<"删除集合中的存在的某个元素ch = "; cin>>ch;
DelElem(dest, ch);
DisplaySet(dest);cout<<endl<<endl;
cout<<"再创建一个集合src = ";
Set src=(Set)malloc(sizeof(ElemNode));
getchar();
CreateSet(src);
cout<<"将src集合链接到集合dest中..."<<endl;
ContactSet(dest, src);
cout<<"此时dest为：";
DisplaySet(dest);
cout<<endl;
if(ExistSubset(dest, src))
cout<<"此时src是dest的子集..."<<endl;
else
cout<<"此时src不是dest的子集..."<<endl;
cout<<endl<<"dest = ";
DisplaySet(dest);
cout<<endl;
cout<<"dest的补集是：";
Set p=(Set)malloc(sizeof(ElemNode));
p->next=NULL;
NegSet(p, dest);
DisplaySet(p);
cout<<endl<<"演示结束!!!"<<endl;
DestroySet(dest);
return 0;
}

//---------------BasicFunctions-----------------------
//------------------函数实现--------------------------
int LengthOf(Set src)
{
//返回一个集合的长度
int i=0;
while(src->next!=NULL)
{
i++;
src=src->next;
}
return i;
}//LengthOf

void CreateSet(Set dest)
{
//创建一个新的字母集合，限定a-z
ElemType ch;
Set p=dest,n;
for(;;)
{
ch=getchar();
if(ch=='\n') break;
if(ch<97||ch>122) continue;
n=(Set)malloc(sizeof(ElemNode));
p->next=n;
n->elem=ch;
n->next=NULL;
p=n;
}
return ;
}//CreateSet

void EmptySet(Set dest)
{
//清空一个集合，保留头结点
Set p,n;
while(dest->next!=NULL)
{
p=dest;
n=p->next;
for(;n->next!=NULL;)
{
p=n;
n=n->next;
}
free(n);
p->next=NULL;
}
}//EmptySet

void DestroySet(Set dest)
{
//销毁集合
EmptySet(dest);
free(dest);
}//DestroySet

void SortSet(Set dest)
{
//对一个字母集合进行从小到大的排序
int i,j,l,flag;
Set p,q,n;
l=LengthOf(dest);
if(l<2) return;
flag=1;
for(i=l-1;i>0&&flag==1;i--)
{
flag=0;
p=dest;
q=p->next;
n=q->next;
for(j=0;j<i;j++)
{
if(q->elem>n->elem)
{
flag=1;
p->next=n;
q->next=n->next;
n->next=q;
q=p->next;
n=q->next;
}
p=q;
q=n;
n=n->next;
}
}
}//SortSet

void DisplaySet(Set src)
{
//打印集合的所有元素
Set p;
if(src->next==NULL)
{
printf("φ");
return ;
}
p=src;
do
{
p=p->next;
putchar(p->elem);
} while(p->next!=NULL);
}//DisplaySet

int ExistElem(Set dest, ElemType e)
{
//判断元素是否存在于集合中
Set p=dest;
if(LengthOf(p)==0)
return 0;
else{
p=p->next;
while(p->elem!=e)
{
if(p->next==NULL)
return 0;
p=p->next;
}
return 1;
}
}//ExistElem

void DelElem(Set dest, ElemType e)
{
//删除集合中的一个元素一次
Set p=dest,q;
if(LengthOf(p)==0)
return ;
q=p->next;
if(LengthOf(p)==1)
{
p->next=NULL;
free(q);
}
while(q->elem!=e)
{
p=p->next;
q=q->next;
}
if(q->next==NULL)
{
p->next=NULL;
free(q);
}
else
p->next=q->next;
}//DelElem

void AddElem(Set dest, ElemType e)
{
//在链表尾部追加一个元素
Set p=dest, n;
while(p->next!=NULL)
p=p->next;
n=(Set)malloc(sizeof(ElemNode));
p->next=n;
n->elem=e;
n->next=NULL;
}//AddElem

void ContactSet(Set dest, Set src)
{
//连接一个集合到另一个集合
Set p=dest;
while(p->next!=NULL)
p=p->next;
p->next=src->next;
}//ContactSet

void AddSet(Set dest, Set src1, Set src2)
{
//集合并运算
SortSet(src1);SortSet(src2);
int i=0,j=0,len1=LengthOf(src1),len2=LengthOf(src2);
src1=src1->next;src2=src2->next;
while(i<len1&&j<len2)
{
if(src1->elem<=src2->elem)
{
i++;
if(!ExistElem(dest, src1->elem))
{
AddElem(dest, src1->elem);
src1=src1->next;
}
else
{
src1=src1->next;
}
}
else
{
j++;
if(!ExistElem(dest, src2->elem))
{
AddElem(dest, src2->elem);
src2=src2->next;
}
else
{
src2=src2->next;
}
}
}
while(i<len1)
{
i++;
if(!ExistElem(dest, src1->elem))
{
AddElem(dest, src1->elem);
src1=src1->next;
}
}
while(j<len2)
{
j++;
if(!ExistElem(dest, src2->elem))
{
AddElem(dest, src2->elem);
src2=src2->next;
}
}
}//AddSet

void MulSet(Set dest, Set src1, Set src2)
{
//集合交运算
SortSet(src1);SortSet(src2);
int i=0,j=0,len1=LengthOf(src1),len2=LengthOf(src2);
src1=src1->next;src2=src2->next;
while(i<len1&&j<len2)
{
if(src1->elem<src2->elem) {i++;src1=src1->next;}
else if(src1->elem>src2->elem) {j++;src2=src2->next;}
else
{
i++;j++;
if(!ExistElem(dest, src1->elem))
{
AddElem(dest, src1->elem);
src1=src1->next;
src2=src2->next;
}
}
}
}//MulSet

void SubSet(Set dest, Set src1, Set src2)
{
//集合差运算
SortSet(src1);SortSet(src2);
int i=0,len=LengthOf(src1);
src1=src1->next;
while(i<len)
{
i++;
if(!ExistElem(src2, src1->elem))
{
if(!ExistElem(dest, src1->elem))
{
AddElem(dest, src1->elem);
src1=src1->next;
}
}
else
{
src1=src1->next;
}
}
}//SubSet

int ExistSubset(Set dest, Set src)
{
//子集判断
int i=0,len=LengthOf(src);
src=src->next;
while(i<len)
{
if(!ExistElem(dest, src->elem))
return 0;
i++;
src=src->next;
}
return 1;
}//ExistSubset

void NegSet(Set dest, Set src)
{
//求补集
SortSet(src);
int i=0;
while(i<26)
{
if(!ExistElem(src, i+97))
AddElem(dest, i+97);
i++;
}
}//NegSet

Ⅶ 有没有谁做过数据结构课程设计,题目为:

题目1 马踏棋盘问题
#include "stdio.h"
#define M 70
#define FALSE 0
#define TRUE 1
typedef struct node
{
int vec,x,y;
struct node *link;
}listnode;

#define MAXSIZE 70
typedef struct
{
int stack[MAXSIZE];
int top;
}seqstack;
seqstack *s;
void setnull(seqstack *s)
{
s->top=-1;
}
int push(seqstack *s,int x)
{
if(s->top>=MAXSIZE-1)
{
printf("stack overflow!\n");
return FALSE;
}
else
{
s->stack[++s->top]=x;/*栈顶指针上移，数据元素入栈*/
return TRUE;
}
}

int pop(seqstack *s)/*出当前栈s的栈顶元素*/
{ int p;
if(s->top<0)
{
printf("stack empty!\n");/* 栈空，返回空值*/
return NULL;
}
else
{
s->top--;
return(s->stack[s->top+1]);
}/*由于return语句的特点，必须先使 top减1，然后再执行return语句。而此时栈顶元素的表示应该为s->top+1*/
}

void creatlist(listnode ag[])
{
listnode *p;
int i,j,x,y,x1,x2,y1,y2,k;
k=1;

for(i=1;i<=8;i++)
{
for(j=1;j<=8;j++)
{
ag[k].x=i;
ag[k].y=j;
ag[k].vec=8*ag[k].x+ag[k].y-8;
ag[k].link=NULL;
printf("%d(%d,%d)",ag[k].vec,ag[k].x,ag[k].y);
k++;
}
printf("\n");
}
for(i=1;i<=64;i++)
{
/*printf("*%d*",i); */
setnull(s);
x1=ag[i].x;
y1=ag[i].y;
if((x1+1>0)&&(y1+2>0)&&(x1+1<=8)&&(y1+2<=8))
{
x2=x1+1;
y2=y1+2;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);

}
if((x1+1>0)&&(y1-2>0)&&(x1+1<=8)&&(y1-2<=8))
{
x2=x1+1;
y2=y1-2;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);
}

if((x1-1>0)&&(y1+2>0)&&(x1-1<=8)&&(y1+2<=8))
{
x2=x1-1;
y2=y1+2;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);
}
if((x1-1>0)&&(y1-2>0)&&(x1-1<=8)&&(y1-2<=8))
{
x2=x1-1;
y2=y1-2;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);
}
if((x1+2>0)&&(y1-1>0)&&(x1+2<=8)&&(y1-1<=8))
{
x2=x1+2;
y2=y1-1;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);
}
if((x1+2>0)&&(y1+1>0)&&(x1+2<=8)&&(y1+1<=8))
{
x2=x1+2;
y2=y1+1;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);
}
if((x1-2>0)&&(y1+1>0)&&(x1-2<=8)&&(y1+1<=8))
{
x2=x1-2;
y2=y1+1;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);
}
if((x1-2>0)&&(y1-1>0)&&(x1-2<=8)&&(y1-1<=8))
{
x2=x1-2;
y2=y1-1;
j=8*x2+y2-8;
/*printf("%d ",j);*/
push(s,j);
}
do
{
j=pop(s);
x2=ag[j].x;
y2=ag[j].y;
p=(listnode *)malloc(sizeof(listnode));
p->vec=j;
p->x=x2;
p->y=y2;
p->link=ag[i].link;
ag[i].link=p;
/*printf(" %d(%d,%d) ",p->vec,p->x,p->y);*/
p=(listnode *)malloc(sizeof(listnode));
p->vec=i;
p->x=x1;
p->y=y1;
p->link=ag[j].link;
ag[j].link=p;
/*printf(" %d(%d,%d) ",p->vec,p->x,p->y);*/

} while(s->top>=0);

}

}

void dfs(listnode ag[],int v,int flag[])
{
listnode *p;
int i;
flag[v]=1;
printf("(%d,%d)",ag[v].x,ag[v].y);
p=ag[v].link;
while(p!=NULL)
{
i=p->vec;
if(flag[i]==0)
dfs(ag,i,flag);
p=p->link;
}

}
/*void blt(listnode ag[M],int n)
{
int i;
int flag[M];
for(i=1;i<=n;i++)
flag[i]=0;
for(i=1;i<=n;i++)
if(flag[i]==0)
dfs(ag,i,flag);
}*/
void main()
{
listnode ag[M];
int flag[M];
creatlist(ag);
dfs(ag,28,flag);
}