数据结构课程设计排序

『壹』 数据结构课程设计教学计划安排检验程序（拓扑排序）

难得碰到个稍微有点意思的问题，虽然没分，也答了吧

输入格式：
第一行，两个整数n和m，分别表示课程数和学期数
然后紧接着n行，每行一个字符串，表示各个课程的名称
然后一个整数k，表示共有k对课程之间有先后关系
然后k行，每行两个字符串s1和s2，表示课程s1必须在课程s2之前学

#include <stdio.h>
#include <memory.h>
#include <string.h>
#define MAXN 25
int n,m;
int indeg[MAXN],outdeg[MAXN];
int list[MAXN][MAXN];
char names[MAXN][15];
int stack[MAXN];
int dep;
int order[MAXN];

int find_id(char *name)
{
int i;
for (i=0;i<n;i++)
if (!strcmp(name,names[i])) return i;
return -1;
}

int main()
{
int i,j,k;
scanf("%d%d",&n,&m);
for (i=0;i<n;i++) scanf("%s",names[i]);
memset(indeg,0,sizeof(indeg));
memset(outdeg,0,sizeof(outdeg));
scanf("%d",&k);
while (k--)
{
char name[15];
scanf("%s",name);
i=find_id(name);
scanf("%s",name);
j=find_id(name);
if (i==-1 || j==-1)
{
puts("Invalid name, please enter again");
k++;
}
else
{
indeg[j]++;
list[i][outdeg[i]++]=j;
}
}
k=0;
dep=0;
for (i=0;i<n;i++)
if (indeg[i]==0) stack[dep++]=i;
while (dep>0)
{
dep--;
i=stack[dep];
order[k++]=i;
while (outdeg[i]>0)
{
j=list[i][--outdeg[i]];
indeg[j]--;
if (indeg[j]==0) stack[dep++]=j;
}
}
if (k<n) puts("No Solution!");
else
{
int d,r;
d=n/m;
r=n%m;
k=0;
for (i=0;i<m;i++)
{
printf("Course(s) in term %d:\n",i+1);
for (j=0;j<d+(i<r ? 1 : 0);j++)
{
puts(names[k]);
k++;
}
putchar('\n');
}
}
}

『贰』 二叉树排序算法实现（数据结构课程设计）

#include <malloc.h>
#include<stdio.h>
#define NUM 7 //宏定义
int i; //变量类型定义
typedef struct Node{
int data ; //数据域
struct Node *next; //指针域
}Node,*LNode; //用结构体构造结点及相应的指针

typedef struct Tree{
int data ;
struct Tree *left ;
struct Tree *right ;
}Tree,*LTree ; //用结构体构造树及相应的指针

CreateList( LNode Head ) //创建单链表
{
for(int i=1 ; i <=NUM ; i++) //创建循环，依次输入NUM个数据
{
LNode temp ; //中间结点
temp = (LNode) malloc( sizeof( Node ) ); //动态存储分配

temp-> next = NULL; //中间结点初始化
scanf("%2d",&temp-> data); //输入赋值到结点temp数据域
temp-> next = Head-> next ;
Head-> next = temp ; //将temp结点插入链表

}
return 1 ;//返回1
}

InsertSqTree( LTree &root , LNode temp ) //二叉树排序原则的设定
{
if(!root) //root为NULL时执行
{
root = (LTree)malloc(sizeof(Tree)); //动态存储分配

root-> left =NULL;
root-> right=NULL; //初始化
root-> data = temp-> data ; //赋值插入
return 1 ; //函数正常执行，返回1
}
else
{
if(root-> data>= temp-> data)
return InsertSqTree( root-> left , temp ) ; //比较插入左子树
else if(root-> data <temp-> data)
return InsertSqTree( root-> right , temp ); //比较插入右子树
}
return 1 ; //如果满足，就不做处理，返回1
}

void BianLiTree(LTree root) //采用中序遍历，实现将所有数字按从左向右递增的顺序排序
{
if(root) //root不为空执行
{BianLiTree(root-> left); //左递归处理至叶子结点，当root-> left为NULL时不执行
printf("%4d ",root-> data); //输出
BianLiTree(root-> right); //处理右结点
}
}

int main()
{
LNode Head = NULL;
LTree root = NULL ; //初始化
Head = (LNode) malloc(sizeof(Node)); //动态存储分配

Head-> next = NULL ; //初始化
printf("please input numbers:\n");//输入提示语句
if(!CreateList( Head )) //建单链表成功返回1不执行下一语句
return 0; //结束函数，返回0
LNode temp = Head-> next ; //将头指针的指针域赋值予中间结点
while( temp ) //temp为NULL时停止执行
{
if(!InsertSqTree( root ,temp )) //排序正常执行，返回1不执行下一语句
return 0 ; //结束函数，返回0
Head-> next = temp-> next ; //将中间指针的指针域赋值予头结点指针域
free(temp); //释放空间
temp = Head-> next ; //将头指针的指针域赋值予中间结点，以上三句实现了temp指针后移
}
printf("the result is:\n");//输出提示语句
BianLiTree(root); //采用中序遍历，输出并观察树结点
return 1; //函数正常结，返回1
}

『叁』 数据结构课程设计：二叉排序树的实现

/*以下是用c++ 实现的二叉排序树的源代码*/

#include<iostream.h>
typedef struct TreeNode
{
int key;
struct TreeNode *left;
struct TreeNode *right;

}treeNode;

class BiSortTree
{
public:
BiSortTree(void);
void desplayTree(void);//显示这个树
void insertTree(int key);//在树中插入一个值
deleteTree(int key);//在树中删除一个值
treeNode* searchTree(int key);//在树中查找一个值

~BiSortTree();

private:
treeNode* buildTree(treeNode* head,int number);//建立一个树
treeNode* search(treeNode* head ,int key);//查找
treeNode* BiSortTree::searchParent(treeNode* head,treeNode* p);//查找出p的父亲节点的指针
treeNode* BiSortTree::searchMinRight(treeNode* head);//找到右子树中最小的节点

void showTree(treeNode* head);//显示
void destroyTree(treeNode* head);//删除

treeNode *Head;

};

/**************以下是建立一个二叉排序树****************/
BiSortTree::BiSortTree()
{
cout<<"建立一棵二叉排序树,请输入你要建树的所有数(以-1 作为结束标志!): "<<endl;
Head=NULL;
int number;
cin>>number;
while(number!=-1)
{
Head=buildTree(Head,number);
cin>>number;

}

}
treeNode* BiSortTree::buildTree(treeNode* head,int number)
{

treeNode *p;
p=new treeNode;
p->key=number;
p->left =p->right=NULL;

if(head==NULL)
{

return p;
}
else
{

if(p->key <head->key)
head->left=buildTree(head->left,number);
else
head->right=buildTree(head->right,number);

return head;
}

}
/*****************以下是在一棵二叉排序树插入一个数***********************************/
void BiSortTree::insertTree(int key)
{

Head=buildTree(Head,key);

}
/*****************以下是在一个二叉排序树查找一个数是否存在*************************/
treeNode* BiSortTree::searchTree(int key)
{
return search(Head,key);
}
treeNode* BiSortTree::search(treeNode* head ,int key)
{
if(head==NULL)
return NULL;
if(head->key==key)
return head;
else
{
if(key<head->key )
return search( head->left,key);

else
return search(head->right,key);

}

}

/************以下是在一个二叉排序树删除一个给定的值*********************************/
BiSortTree::deleteTree(int key)
{

treeNode *p;
p=NULL;
p=search(Head,key);
if(p==NULL)
{
cout<<"Don't find the key";

}
if(p==Head)
{
Head=NULL;

}
else
{
treeNode* parent;
parent=searchParent(Head,p);
if(p->left==NULL&&p->right==NULL)//叶子节点
{
if(parent->left==p)
{
parent->left=NULL;
}
else
{
parent->right=NULL;

}
}
else//非叶子节点
{
if(p->right==NULL)//该节点没有右孩子
{
if(parent->left==p)
{
parent->left=p->left ;
}
else
{
parent->right=p->left;

}
}

else//该点有左右孩子
{
treeNode * rightMinSon,* secondParent;//secondParent为右子树中的最小节点的父亲
rightMinSon=searchMinRight(p->right);
secondParent=searchParent(p->right ,rightMinSon);

secondParent->left=rightMinSon->right;

if(p->right==rightMinSon)//右子树中的最小节点的父亲为p
{

p->right=rightMinSon->right ;

}

p->key=rightMinSon->key ;

}
}
}
}

treeNode* BiSortTree::searchParent(treeNode* head,treeNode* p)
{

if(head->left==p||head->right==p||head==p||head==NULL)
return head;
else
{
if(p->key<head->key)
return searchParent(head->left ,p);
else
return searchParent(head->right ,p);

}

}

treeNode* BiSortTree::searchMinRight(treeNode* head)//找到右子树中最小的节点
{

if(head->left ==NULL||head==NULL)
{
return head;

}
else
{
return searchMinRight(head->left);

}

}

/*****************以下是显示一个二叉排序树****************************************/
void BiSortTree::desplayTree(void)
{

showTree(Head);
cout<<endl;
}
void BiSortTree::showTree(treeNode* Head)
{

if(Head!=NULL)
{
showTree(Head->left ) ;

cout<<Head->key<<' ' ;

showTree(Head->right) ;

}

}

/*****************以下是删除一棵整二叉排序树************************************/
BiSortTree::~BiSortTree()
{
cout<<"已经消除了一棵树!!!!"<<endl;
destroyTree(Head);
}
void BiSortTree::destroyTree(treeNode* head )
{

if(head!=NULL)
{
destroyTree(head->left );
destroyTree(head->right );
delete head;

}

}

/*********************/
void print()
{

cout<<endl<<endl<<"以下是对二叉排序树的基本操作:"<<endl
<<"1.显示树"<<endl
<<"2.插入一个节点"<<endl
<<"3.寻找一个节点"<<endl
<<"4.删除一个节点"<<endl;
}

void main()
{
BiSortTree tree;
int number;
int choiceNumber;
char flag;
while(1)
{
print() ;

cout<<"请选择你要进行的操作(1~4)"<<endl;
cin>>choiceNumber;
switch(choiceNumber)
{
case 1:
tree.desplayTree();break;
case 2:
cout<<"请插入一个数: "<<endl;
cin>>number;
tree.insertTree(number);
tree.desplayTree();
break;

case 3:
cout<<"请插入你要找数: "<<endl;
cin>>number;
if(tree.searchTree(number)==NULL)
{
cout<<"没有发现"<<endl;
}
else
{

cout<<"发现"<<endl;

}
break;

case 4:
cout<<"请输入你要删除的数: "<<endl;
cin>>number;
tree.deleteTree(number);
tree.desplayTree();
break;

default: break;
}
cout<<"你是否要继续(Y/N)?"<<endl;
cin>>flag;
if(flag=='N'||flag=='n')
break;

}

}

『肆』 数据结构课程设计 二叉排序树的实现 追加150分

#include "stdio.h"
#include "string.h"
#define max 7
#define null 0
typedef struct node
{
char data[7];
struct node *lchild,*rchild;
}btree;
btree *q[max];
btree *creatbtree();
ceng(btree *bt);
main()
{
btree *head;
head=creatbtree();
ceng(head);
}
btree *creatbtree()
{
char ch1[7];
int front,rear;
btree *root,*s;
front=1,rear=0;
root=null;
printf("shu ru Data,Empty place input @,the end is #\n");
scanf("%s",ch1);
while(strcmp(ch1,"#"))
{
s=null;
if(strcmp(ch1,"@"))
{
s=(btree*)malloc(sizeof(btree));
strcpy(s->data,ch1);
s->lchild=null;
s->rchild=null;
}
rear++;
q[rear]=s;
if(rear==1)
root=s;
else
{
if(q[front]&&s)
if(rear%2==0)
q[front]->lchild=s;
else
{
q[front]->rchild=s;
front++;
}
}
scanf("%s",ch1);
}
return root;
}
ceng(btree *bt)
{
int front=0,rear=0;
if(bt!=null)
{
rear++;
q[rear]=bt;
}
while(front!=rear)
{
front++;
bt=q[front];
printf("%s,",bt->data);
if(bt->lchild!=null)
{
rear++;
q[rear]=bt->lchild;
}
if(bt->rchild!=null)
{
rear++;
q[rear]=bt->rchild;
}
}
}

『伍』 数据结构课程设计综合排序代码及实验报告书。

需要对条目进行自动排序，当增加或减少条目时，下面的会自动进行再排序，你回答中的格式--样式和格式的操作，我不是很明白，要怎么操作才能实现自动排序。

『陆』 数据结构课程设计，二叉排序树。

//调式完毕，你后把不必要的注释可以去掉，交作业吧，记得采纳，这程序大部分是你自己的功劳
#include<iostream.>
#include<stdio.h>
using namespace std;
typedef int KeyType;
#define MaxElement 1024 //因二叉树结构，实际输入元素不能过多，否则递归调用时可能出异常
typedef struct tree//声明树的结构
{
struct tree *left; //存放左子树的指针
struct tree *right; //存放又子树的指针
KeyType key; //存放节点的内容
} BSTNode, * BSTree; //声明二叉树的链表

int insertBST(BSTree &pRoot,KeyType key) // 在二叉排序树中插入结点 参数:改为根结点的引用 key值 Ok了
{//若二叉排序树tptr中没有关键字为key的结点，则插入，否则直接返回
BSTree f,p=pRoot; //p的初值指向根结点
while(p) //查找插入位置，循环结束时，p是空指针，f指向待插入结点的双亲
{
if(p->key==key) //树中已有key，无须插入
return 0;
f=p; //f保存当前查找的结点，即f是p的双亲
p=(key<p->key)?p->left:p->right;
}
p=(BSTree)malloc(sizeof(BSTNode)); //生成新结点
p->key=key; p->left=p->right=NULL;
if(pRoot==NULL) //原树为空，新插入的结点为新的根
pRoot=p;
else
if(key<f->key)
f->left=p;
else
f->right=p;
return 1;
}

BSTree createBST(int *iArr)//建立二叉树
{//这个不方便重复使用,大改一下了, 参数中有则直接用参数中的，没有则键盘输入
BSTree t=NULL; //根结点
KeyType key;
int i=0;
if(!*iArr)
{
cin>>key;
while(key!=-1 && ++i<MaxElement)//输入-1或输入到最大个数止
{
(*iArr)++;iArr[*iArr] = key;//集合元素先在数组中存放
cin>>key;
}
}
for(i=1;i<=*iArr;i++) //由数组形式 生成 二叉树状集合形式
{
insertBST(t,iArr[i]);
}
return t;
}

void inorder_btree(BSTree root)// 中序遍历打印二叉排序树 OK
{
BSTree p=root;
if(p!=NULL){
inorder_btree(p->left );
cout<<" "<<p->key<<" ";
inorder_btree(p->right );
}
}

BSTree searchBST(BSTree t,KeyType key)//元素判定 注意 Ok
{ //这里稍改，返回结点指针或空 比较合适
//if(key==t->key)return t->key; //如果不是它的元素，你这会先访问了一个空指针的结点
//if(t==NULL)return 0; 上下这两行顺序放错了先这行再上面一行还可以 且0也可能是元素之一
//综合起来就是这个返回类型定得不合适，改为返回指针，未找到时返回空指针 找到时返回所在位置
if(!t || key==t->key) return t; //<<< 先判是不是空指针，非空了再判是不是相等了
if(key<t->key)
return searchBST(t->left,key);
else
return searchBST(t->right,key);
}

int deleteBST(BSTree &pRoot,KeyType key)//删除 本函数暂未测试
{
BSTree p,tmp,parent=NULL;
p=pRoot;
while(p)
{
if(p->key==key)
break;
parent=p;
p=(key<p->key)?p->left:p->right;
}
if(!p) return 0;
tmp=p;
if(!p->right&&!p->left) /*p的左右子树都为空*/
{
if(!parent) //要删根，须修改根指针
pRoot=NULL;
else if(p==parent->right)
parent->right=NULL;
else
parent->left=NULL;
free(p);
}
else if(!p->right) //p的右子树为空，则重接p的左子树
{
p=p->left;
if(!parent) //要删根，须修改根指针
pRoot=p;
else if(tmp==parent->left)
parent->left=p;
else
parent->right=p;
free(tmp);
}
else if(!p->left) //的左子树为空，则重接p的左子树
{
p=p->right;
if(!parent) //要删根，须修改根指针
pRoot=p;
else if(tmp==parent->left)
parent->left=p;
else
parent->right=p;
free(tmp);
}
else if(p->right&&p->left) //p有左子树和右子树，用p的后继覆盖p然后删去后继
{ //另有方法：用p的前驱覆盖p然后删去前驱||合并p的左右子树
parent=p; //由于用覆盖法删根，则不必特殊考虑删根
p=p->right;
while(p->left)
{
parent=p;
p=p->left;
}
tmp->key=p->key;
if(p==parent->left)
parent->left=NULL;
else
parent->right=NULL;
free(p);
}
return 1;
}

void inorder_btree2Arr(BSTree root,int *Arr)//中序遍历 输出到数组中 数组第0个元素放个数(初始必需为0)
{
BSTree p=root;
if(p!=NULL){
inorder_btree2Arr(p->left, Arr);
(*Arr)++; //<<<数组首个地址进来之前一定要置为0!!!! 我约定的，不许赖啊 否则程序死掉不怨我
Arr[*Arr] = p->key; //Arr[*Arr]等价于Arr[Arr[0]]
inorder_btree2Arr(p->right, Arr);
}
}

void inorder_btreeCount(BSTree root,int &n)//统计个数 n 初始必需为0 否则数得不对
{
BSTree p=root;
if(p!=NULL){
inorder_btreeCount(p->left, n);
n++;
inorder_btreeCount(p->right, n);
}
}

int beyong(BSTree m,BSTree n) //子集判定
{
//if(m->key==n->left)//这是什么算法啊，我看不懂呀 汗 是语法错误!! 只得改写了
//return m->key;
//else
// return 0;
int i,Array[MaxElement]={0};//不懂怎么一个一个的来访问树结点，只好使个懒人的方法，转成数组，再遍历数组啦
inorder_btree2Arr(n,Array);//返回的数组第一元素为长度，之后是数据
for(i=1;i<=*Array;i++)
if(!searchBST(m,Array[i])) return 0;//有元素找不着就不是子集了
return 1;//都能找着，就是子集
}

void combineTree(BSTree A,BSTree B,BSTree &C) //A+B=C 并集
{
int i,Array[MaxElement]={0};
inorder_btree2Arr(A,Array);
C = createBST(Array); //A 先复制到 C
Array[0]=0;
inorder_btree2Arr(B,Array);
for(i=1; i<=*Array; i++) insertBST(C,Array[i]);//B的每个元素试着插入C,重复元素自动忽略
}

void joinTree(BSTree A,BSTree B,BSTree &C) //A*B=C 交集
{
int i,Array[MaxElement]={0},Array1[MaxElement]={0};
inorder_btree2Arr(B,Array);
for(i=1;i<=*Array;i++)
if(searchBST(A,Array[i])){Array1[0]++; Array1[Array1[0]] = Array[i];}//求相交的所有元素
if(Array1[0]) C = createBST(Array1); //结果不空时 再组一个集合
else C=NULL;
}

void differencedTree(BSTree A,BSTree B,BSTree &C) //A-B=C 差集
{
int i,Array[MaxElement]={0},Array1[MaxElement]={0};
inorder_btree2Arr(A,Array);//列出A中所有元素
for(i=1;i<=*Array;i++)
if(!searchBST(B,Array[i])){Array1[0]++; Array1[Array1[0]] = Array[i];}//求出不属于B的所有元素
if(Array1[0]) C = createBST(Array1); //结果不空时 再组一个集合
else C=NULL;
}

int main()
{
int i,e;
int iArray[MaxElement]={0};//数组形式的整数集合 做输入输出缓冲,输入时先在这暂存
BSTree root1,root2,root3,root4,root5;
cout<<"请输入你所要创建的集合LA，以-1结束：\n"; //<<<怎么看着不伦不类呀，这换行，有C风格的\n
iArray[0]=0;
root1=createBST(iArray);
cout<<"\n\n中序遍历二叉树："<<endl;//<<<又有C++风格的endl 不过编译器都不反对哦，我忍了
inorder_btree(root1);
cout<<"\n"<<endl;
printf("请输入e的值:");
scanf("%d",&e);
if(searchBST(root1,e))//元素判定
printf("元素e(%d)属于集合\n",e);
else
printf("元素e(%d)不属于集合\n",e);

cout<<"请输入你所要创建的集合LB，以-1结束：\n";
iArray[0]=0;
root2=createBST(iArray);

cout<<"\n求子集:"<<endl;
i=beyong(root1,root2);
if(i)//子集判定
printf("集合LB包含于LA\n");
else
printf("集合LB不包含于LA\n");
i=beyong(root2,root1);
if(i)//子集判定
printf("集合LA包含于LB\n");
else
printf("集合LA不包含于LB\n");

cout<<"\n求并集:";
combineTree(root1,root2,root3);
if(!root3)
cout<<"LA+LB 并集怎会是空的，怪鸟!"<<endl;
else
{
cout<<"中序遍历 LA+LB 的交集二叉树："<<endl;
inorder_btree(root3);
}

cout<<"\n求交集:";
joinTree(root1,root2,root4);
if(!root4)
cout<<"LA*LB 交集怎会是空的? 有可能!"<<endl;
else
{
cout<<"中序遍历 LA*LB 的交集二叉树："<<endl;
inorder_btree(root4);
}

cout<<"\n求差集:";
differencedTree(root1,root2,root5);
if(!root5)
cout<<"LA-LB 差集怎会是空的? 有可能!"<<endl;
else
{
cout<<"中序遍历LA-LB的交集二叉树："<<endl;
inorder_btree(root5);
}
//内存资源系统能很好的收回，据说咱分配的一堆内存垃圾就丢那不理了也没事哦, 若作服务程序可就不要这样
}

『柒』 c语言 数据结构 排序综合 课程设计

给你发了 不只3种 给你5种了 363173922的 记得给我加分 有问题加我再给你解决 没分就免谈 好了都给你搞定了

『捌』 数据结构课程设计 排序

要代码我可以给你写 其它的就要你自己写了

『玖』 数据结构课程设计 图的拓扑排序的实现 在线等啊

有一个非常简单的方法：
1、全选A列进行排序（升序或降序），排序提醒选择以当前选定区域排序。
2、全选B列进行上一步同样的操作。
就达到最终结果了。

『拾』 数据结构课程设计的各种排序算法的综合比较 哪位大神帮写一下~

排序法 平均时间 最差情形 稳定度 额外空间 备注
冒泡 O(n2) O(n2) 稳定 O(1) n小时较好
交换 O(n2) O(n2) 不稳定 O(1) n小时较好
选择 O(n2) O(n2) 不稳定 O(1) n小时较好
插入 O(n2) O(n2) 稳定 O(1) 大部分已排序时较好
基数 O(logRB) O(logRB) 稳定 O(n) B是真数(0-9)，R是基数(个十百)
Shell O(nlogn) O(ns) 1<s<2 不稳定 O(1) s是所选分组
快速 O(nlogn) O(n2) 不稳定 O(nlogn) n大时较好
归并 O(nlogn) O(nlogn) 稳定 O(1) n大时较好
堆 O(nlogn) O(nlogn) 不稳定 O(1) n大时较好