數據結構課程設計排序

『壹』 數據結構課程設計教學計劃安排檢驗程序（拓撲排序）

難得碰到個稍微有點意思的問題，雖然沒分，也答了吧

輸入格式：
第一行，兩個整數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大時較好