演算法與數據結構課程設計

❸ 數據結構與演算法課程設計里 題目為棧的實現和應用，急！！！！！！！！

http://wenku..com/view/71324821dd36a32d7375818b.html

看看吧 給你找到了

❹ 二叉樹排序演算法實現（數據結構課程設計）

#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
}

❺ 數據結構課程設計:排序演算法性能比較 編寫程序在運行時產生1000個隨機整數,分

#include<stdio.h>
#include<stdlib.h>
#include <math.h>
#define L 8 //排序元素個數
#define FALSE 0
#define TRUE 1

typedef struct
{
int key;
char otherinfo;
}RecType;

typedef RecType Seqlist[L+1];
int num; //定義排序趟數的全局變數
Seqlist R;
//直接插入排序
void Insertsort()
{
int i,j,k,m=0;
printf("\n\t\t原始數據為（按回車鍵開始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=2;i<=L;i++)
{
if(R[i].key<R[i-1].key)
{
R[0]=R[i];
j=i-1;
while(R[0].key<R[j].key)
{
R[j+1]=R[j];
j--;
}
R[j+1]=R[0];
}
m++;
printf("\t\t第%d趟排序結果為（按回車鍵繼續）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最終結果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//希爾排序
void Shellsort()
{
int i,j,gap,x,m=0,k;
printf("\n\t\t原始數據為（按回車鍵開始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
gap=L/2;
while(gap>0)
{
for(i=gap+1;i<=L;i++)
{
j=i-gap;
while(j>0)
{
if(R[j].key>R[j+gap].key)
{
x=R[j].key;
R[j].key=R[j+gap].key;
R[j+gap].key=x;
j=j-gap;
}
else
{
j=0;
}
}
}
gap=gap/2;
m++;
printf("\t\t第%d趟排序結果為（按回車鍵開始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最終結果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//冒泡排序
void Bubblesort()
{
int i,j,k;
int exchange;
printf("\n\t\t原始數據為（按回車鍵開始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
exchange=FALSE;
for(j=L;j>=i+1;j--)
{
if(R[j].key<R[j-1].key)
{
R[0].key=R[j].key;
R[j].key=R[j-1].key;
R[j-1].key=R[0].key;
exchange=TRUE;
}
}
if(exchange)
{
printf("\t\t第%d趟排序結果為（按回車鍵開始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
}
printf("\n\t\t排序的最終結果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}

int Partition(int i,int j) //i和j為形式參數，分別代表low和high
{
RecType pirot=R[i];
while(i<j)
{
while(i<j&&R[j].key>=pirot.key)
{
j--;
}
if(i<j)
{
R[i++]=R[j];
}
while(i<j&&R[j].key<=pirot.key)
{
i++;
}
if(i<j)
{
R[j--]=R[i];
}
}
R[i]=pirot;
return i;
}
//遞歸形式為快速排序
void Quicksort(int low,int high)
{
int pirotpos,k;
if(low<high)
{
pirotpos=Partition(low,high);
num++;
printf("\t\t第%d趟排序結果為（按回車鍵開始排序）：\n\t\t",num);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
Quicksort(low,pirotpos-1);
Quicksort(pirotpos+1,high);
}
}
//選擇排序
void Selectsort()
{
int i,j,k,h;
printf("\n\t\t原始數據為（按回車鍵開始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(i=1;i<L;i++)
{
h=i;
for(j=i+1;j<=L;j++)
{
if(R[j].key<R[h].key)
{
h=j;
}
}
if(h!=j)
{
R[0]=R[i];
R[i]=R[h];
R[h]=R[0];
}
printf("\t\t第%d趟排序結果為（按回車鍵開始排序）：\n\t\t",i);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最終結果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}

void Merge(int low,int mm,int high)
{
int i=low,j=mm+1,p=0;
RecType *R1;
R1=new RecType[high-low+1];
if(!R1)
{
printf("內存容量不夠！");
}
while(i<=mm&&j<=high)
{
R1[p++]=(R[i].key<=R[j].key)?R[i++]:R[j++];
}
while(i<=mm)
{
R1[p++]=R[i++];
}
while(j<=high)
{
R1[p++]=R[j++];
}
for(p=0,i=low;i<=high;p++,i++)
{
R[i]=R1[p];
}
}

void MergePass(int length)
{
int i;
for(i=1;i+2*length-1<=L;i=i+2*length)
{
Merge(i,i+length-1,i+2*length-1);
}
if(i+length-1<L)
{
Merge(i,i+length-1,L);
}
}
//歸並排序
void Mergesort()
{
int length,k,m=0,i;
printf("\n\t\t原始數據為（按回車鍵開始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
for(length=1;length<L;length*=2)
{
MergePass(length);
m++;
printf("\t\t第%d趟排序結果為（按回車鍵開始排序）：\n\t\t",m);
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
}
printf("\n\t\t排序的最終結果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}
//堆建
void CreateHeap(int root,int index)
{
int j,temp,finish;
j=2*root;
temp=R[root].key;
finish=0;
while(j<=index&&finish==0)
{
if(j<index)
{
if(R[j].key<R[j+1].key)
{
j++;
}
}
if(temp>=R[j].key)
{
finish=1;
}
else
{
R[j/2].key=R[j].key;
j=j*2;
}
}
R[j/2].key=temp;
}//堆排序
void Heapsort()
{
int i,j,temp,k;
for(i=(L/2);i>=1;i--)
{
CreateHeap(i,L);
}
for(i=L-1,k=1;i>=1;i--,k++)
{
temp=R[i+1].key;
R[i+1].key=R[1].key;
R[1].key=temp;
CreateHeap(1,i);
printf("\t\t第%d趟排序結果為（按回車鍵開始排序）：\n\t\t",k);
for(j=1;j<=L;j++)
{
printf("%5d",R[j].key);
}
getchar();
printf("\n");
}
}
void Heap()
{
int i;
printf("\n\t\t原始數據為（按回車鍵開始排序）：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
getchar();
printf("\n");
Heapsort();
printf("\n\t\t排序的最終結果是：\n\t\t");
for(i=1;i<=L;i++)
{
printf("%5d",R[i].key);
}
printf("\n");
}

main()
{
Seqlist S;
int i,k;
char ch1,ch2,q;
printf("\n\t\t1000個隨機數產生：\n\t\t");
for(i=1;i<=1000;i++)
{

S[i].key = rand() % 999 + 1; //產生1-1000的隨機數
//printf("%d\n", number); // 去掉注釋顯示隨機數的輸出}
printf("\n\t\t排序數據已經輸入完畢！");
ch1='y';
while(ch1=='y'||ch1=='Y')
{
printf("\n");
printf("\n\t\t 排 序 子 系 統 \n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t* 1--------更新排序數據 *\n");
printf("\n\t\t* 2--------直接插入排序 *\n");
printf("\n\t\t* 3--------希 爾 排 序 *\n");
printf("\n\t\t* 4--------冒 泡 排 序 *\n");
printf("\n\t\t* 5--------快 速 排 序 *\n");
printf("\n\t\t* 6--------選 擇 排 序 *\n");
printf("\n\t\t* 7--------歸 並 排 序 *\n");
printf("\n\t\t* 8--------堆 排 序 *\n");
printf("\n\t\t* 0--------返 回 *\n");
printf("\n\t\t*******************************************\n");
printf("\n\t\t 請選擇菜單號（0--8）：");
scanf("%c",&ch2);
getchar();
for(i=1;i<=L;i++)
{
R[i].key=S[i].key;
}
switch(ch2)
{
case '1':
printf("\n\t\t請輸入%d個待排序數據（按回車鍵分隔）：\n\t\t",L);
for(i=1;i<=L;i++)
{
scanf("%d",&S[i].key);
getchar();
printf("\t\t");
}
printf("\n\t\t排序數據已經輸入完畢！");
break;
case '2':
Insertsort();
break;
case '3':
Shellsort();
break;
case '4':
Bubblesort();
break;
case '5':
printf("\n\t\t原始數據為（按回車鍵開始排序）：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
getchar();
printf("\n");
num=0;
Quicksort(1,L);
printf("\n\t\t排序的最終結果是：\n\t\t");
for(k=1;k<=L;k++)
{
printf("%5d",R[k].key);
}
printf("\n");
break;
case '6':
Selectsort();
break;
case '7':
Mergesort();
break;
case '8':
Heap();
break;
case '0':
ch1='n';
break;
default:
system("cls");
printf("\n\t\t 對不起，您的輸入有誤，請重新輸入！\n");
break;
}
if(ch2!='0')
{
if(ch2=='2'||ch2=='3'||ch2=='4'||ch2=='5'||ch2=='6'||ch2=='7'||ch2=='8')
{
printf("\n\n\t\t排序輸出完畢！");
printf("\n\t\t按回車鍵返回。");
q=getchar();
if(q!='\xA')
{
getchar();
ch1='n';
}
}
}
}
}

❻ 數據結構課程設計（C版語言）二叉排序樹演算法

#include<stdio.h>
#include<stdlib.h>
#include<conio.h>

typedef int DataType; //定義數據類型,以int為例

struct BSTNode //定義二叉排序樹節點類型
{
DataType data;
struct BSTNode *lchild,*rchild;
};
int insert(struct BSTNode **root,DataType data) //插入一個節點,成功返回1，否則返回0
{
struct BSTNode *newNode=(struct BSTNode*)malloc(sizeof(struct BSTNode));
newNode->data=data;
newNode->lchild=newNode->rchild=NULL;
if(*root==NULL) //為空則直接插入
{
*root=newNode;
return 1;
}
if((*root)->data==data) //找到相同元素則返回
return 0;
else if(data<(*root)->data) //遞推插入左子樹
return insert(&(*root)->lchild,data);
else //遞推插入右子樹
return insert(&(*root)->rchild,data);
}
void preorder(struct BSTNode *root) //先序遍歷
{

if(root==NULL)
return;
printf("%d ",root->data);
preorder(root->lchild);
preorder(root->rchild);
}

void inorder(struct BSTNode *root) //中序遍歷,結果必然是由小到大排序
{
if(root==NULL)
return;
inorder(root->lchild);
printf("%d ",root->data);
inorder(root->rchild);
}

int delNode(struct BSTNode **root,DataType key) //在二叉樹root中刪除關鍵字為key的節點
{
/*
刪除*p結點的三種情況
(1)*p是葉子(即它的孩子數為0)
無須連接*p的子樹，只需將*p的雙親*parent中指向*p的指針域置空即可。
(2)*p只有一個孩子*child
只需將*child和*p的雙親直接連接後，即可刪去*p。
注意：
*p既可能是*parent的左孩子也可能是其右孩子，而*child可能是*p的左孩子或右孩子，故共有4種狀態;
(3)*p有兩個孩子
先令q=p，將被刪結點的地址保存在q中；然後找*q的中序後繼*p，並在查找過程中仍用parent記住*p的雙親位置。
*q的中序後繼*p一定是*q的右子樹中最左下的結點，它無左子樹。
因此，可以將刪去*q的操作轉換為刪去的*p的操作，即在釋放結點*p之前將其數據復制到*q中，就相當於刪去了*q。
*/
struct BSTNode *parent=NULL,*p=*root,*q,*child;
while(p){ //從根開始查找關鍵字為key的待刪結點
if(p->data==key)
break; //已找到，跳出查找循環
parent=p; //parent指向*p的雙親
p=(key<p->data) ? p->lchild : p->rchild; //在關p的左或右子樹中繼續找
}
if(!p)
return 0;
q=p; //q記住被刪結點*p
if(q->lchild && q->rchild) //*q的兩個孩子均非空，故找*q的中序後繼*p
for(parent=q,p=q->rchild;p->lchild;parent=p,p=p->lchild);
//現在情況(3)已被轉換為情況(2)，而情況(1)相當於是情況(2)中child=NULL的狀況
child=(p->lchild)? p->lchild:p->rchild;//若是情況(2)，則child非空；否則child為空
if(!parent) //*p的雙親為空，說明*p為根，刪*p後應修改根指針
*root=child;//若是情況(1)，則刪去*p後，樹為空；否則child變為根
else
{ //*p不是根，將*p的孩子和*p的雙親進行連接，*p從樹上被摘下
if(p==parent->lchild) //*p是雙親的左孩子
parent->lchild=child;//*child作為*parent的左孩子
else parent->rchild=child;//*child作為 parent的右孩子

if(p!=q) //是情況(3)，需將*p的數據復制到*q
q->data=p->data;//若還有其它數據域亦需復制
}
free(p);//釋放*p佔用的空間
return 1;
}

void main()
{
int i,key;
char choice;
struct BSTNode *root=NULL; //建立一棵空樹
DataType data[]={5,2,9,4,6,1,7,3}; //節點元素
for(i=0;i<sizeof(data)/sizeof(data[0]);i++)
{
insert(&root,data[i]);
}
printf("\t**********************\n");
printf("\t1,插入一個節點\n");
printf("\t2,刪除一個節點\n");
printf("\t3,輸出先序遍歷\n");
printf("\t4,輸出中序遍歷\n");
printf("\t5,退出\n");
printf("\t**********************\n");

while(1)
{
printf("請按鍵選擇操作(1~5)\n");
fflush(stdin);
choice=getch();
switch(choice)
{
case '1':
printf("輸入插入元素:");
scanf("%d",&key);
if(insert(&root,key))
printf("插入成功\n");
else
printf("已存在此元素\n");
break;
case '2':
printf("輸入刪除元素:");
scanf("%d",&key);
if(delNode(&root,key))
printf("刪除成功\n");
else
printf("不存在此元素\n");
break;
case '3':
preorder(root);
printf("\n");
break;
case '4':
inorder(root);
printf("\n");
break;
case '5':
exit(0);
default:
printf("按鍵錯誤\n");
}
}
}

❼ 數據結構與演算法課程設計求助

看上去有點象游戲引擎。
我最近也在研究這個。

不過，這是編譯原理的范疇。

具體實現起來很復雜的，不過，可以給你一些大致的思路：

1、文本編輯器或者源代碼讀取程序（可以是用戶輸入或者從文件讀入）
2、詞法分析。（其實詞法分析就是將各個元素比如變數、關鍵字、運算符等分離出來）
3、語法分析，語義分析。（其作用是生成語法樹）
4、解釋器，運行時環境。（維護程序運行時的環境，比如局部變數的建立、撤銷；函數調用時環境的保存；堆、棧維護等。另外，還要提供固有命令（函數）的實現，就是說，用戶調用了固有的命令時，將會發生什麼。）

總的來說，很復雜的。這是一個很大的項目。別說200分，就是2000元，也很難找到。

推薦你看看編譯原理（不過國內的編譯原理的書籍，都只講皮毛，要看就看英文的）另外，有一本《高級游戲腳本程序設計》不錯。

再就是，你可以使用現成的語法分析生成器，比如：Lex＋Yacc，不過需要修改生成的代碼，才能在VC中使用。

❽ 數據結構課程設計,綜合查找演算法

#include <stdio.h>

typedef int KeyType;
typedef struct{
KeyType key;
int maths;
int english;
}ElemType;
#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)< (b))
#define LQ(a,b) ((a)<=(b))

typedef struct {
ElemType *elem;
int length;
}SSTable;

int Search_Seq(SSTable ST,KeyType key)
{
int i;
ST.elem[0].key=key;
for(i=ST.length; !EQ(ST.elem[i].key,key); --i);
return i;
}

int Search_Bin(SSTable ST,KeyType key)
{
int low,mid,high;
low=1;high=ST.length;
while(low<=high){
mid=(low+high)/2;
if EQ(key,ST.elem[mid].key) return mid;
else if LT(key,ST.elem[mid].key) high=mid -1;
else low=mid +1;
}
}

getdata(SSTable * t)
{
FILE *fp;
int i=1;
fp=fopen("stu.txt","r");
fscanf(fp,"%d",&(t->length));
while(i<=t->length)
{
fscanf(fp,"%d %d %d",&(t->elem[i].key),
&(t->elem[i].maths),&(t->elem[i].english) );
i++;
}
fclose(fp);
}

main()
{
ElemType stu[50];
SSTable class;
int i,j,k;
long time;
class.elem=stu;

getdata(&class);

printf("This class has %d students.\n",class.length);
printf("Input stuno you want search:\n");
scanf("%d",&k);

i=Search_Seq(class,k);
j=Search_Bin(class,k);
printf("Maths English\n");
printf("%d %d\n",class.elem[i].maths,class.elem[i].english);
printf("%d %d\n",class.elem[j].maths,class.elem[j].english);

for(i=1;i<=4;i++)
{j=stu[i].maths+stu[i].english;
printf("%d\n",j);
}

}
二叉排序樹

示例

#include <alloc.h>

#define ERROR 0;
#define FALSE 0;
#define TRUE 1;
#define OK 1;

typedef int ElemType;
typedef int Status;
typedef int KeyType;

#define EQ(a,b) ((a)==(b))
#define LT(a,b) ((a)< (b))
#define LQ(a,b) ((a)<=(b))

typedef struct BinaryTree

{
ElemType data;
struct BinaryTree *l;
struct BinaryTree *r;
}*BiTree,BiNode;

BiNode * new()
{
return( (BiNode *)malloc(sizeof(BiNode)) );
}

CreateSubTree(BiTree *T,ElemType *all,int i)
{
if ((all[i]==0)||i>16)
{
*T=NULL;
return OK;
}
*T=new();
if(*T==NULL) return ERROR;
(*T)->data=all[i];
CreateSubTree(&((*T)->l),all,2*i);
CreateSubTree(&((*T)->r),all,2*i+1);
}

CreateBiTree(BiTree *T)
{
ElemType all[16]={0,1,2,3,0,0,4,5,0,0,0,0,6,0,0,0,};
CreateSubTree(T,all,1);
}

printelem(ElemType d)
{
printf("%d\n",d);
}

PreOrderTraverse(BiTree T,int (*Visit)(ElemType d))
{
if(T){
if(Visit(T->data))
if(PreOrderTraverse(T->l,Visit))
if(PreOrderTraverse(T->r,Visit)) return OK;
return ERROR;
} else return OK;
}

InOrderTraverse(BiTree T,int (*Visit)(ElemType d))
{
if(T){
if(InOrderTraverse(T->l,Visit))
if(Visit(T->data))
if(InOrderTraverse(T->r,Visit)) return OK;
return ERROR;
}else return OK;
}

Status SearchBST(BiTree T,KeyType key,BiTree f,BiTree *p){

if(!T) {*p=f;return FALSE;}
else if EQ(key,T->data){ *p=T;return TRUE;}
else if LT(key,T->data) SearchBST(T->l,key,T,p);
else SearchBST(T->r,key,T,p);
}

Status InsertBST(BiTree *T,ElemType e){
BiTree p;
BiTree s;
if(!SearchBST(*T,e,NULL,&p)){
s=(BiTree)malloc(sizeof(BiNode));
s->data=e;s->l=s->r=NULL;
if(!p) *T=s;
else if (LT(e,p->data)) p->l=s;
else p->r=s;
return TRUE;
}
else return FALSE;
}

void Delete(BiTree *p){
BiTree q,s;
if(!(*p)->r){
q=(*p);
(*p)=(*p)->l;
free(q);
}
else if(!(*p)->l){
q=(*p);
(*p)=(*p)->r;
free(q);
}
else {

/* q=(*p);
s=(*p)->l;
while(s->r) {q=s; s=s->r;}
(*p)->data=s->data;
if(q!=(*p) ) q->r=s->l;
else q->l=s->l;
free(s);
*/

q=s=(*p)->l;
while(s->r) s=s->r;
s->r=(*p)->r;
free(*p);
(*p)=q;

}
}

Status DeleteBST(BiTree *T,KeyType key){
if (!(*T) )
{return FALSE;}
else{
if ( EQ(key,(*T)->data)) Delete(T);
else if ( LT(key,(*T)->data)) DeleteBST( &((*T)->l), key);
else DeleteBST( &((*T)->r),key);
return TRUE;
}
}

main()
{
BiTree root;
BiTree sroot=NULL;
int i;
int a[10]={45,23,12,3,33, 27,56,90,120,62};
system("cls");
CreateBiTree(&root);
printf("PreOrderTraverse:\n");
PreOrderTraverse(root,printelem);
printf("InOrderTraverse:\n");
InOrderTraverse(root,printelem);
for(i=0;i<10;i++)
InsertBST(&sroot,a[i]);
printf("InOrderTraverse:\n");
InOrderTraverse(sroot,printelem);
for(i=0;i<3;i++)
DeleteBST(&sroot,a[i]);
printf("Now sroot has nodes:\n");
InOrderTraverse(sroot,printelem);
}

❾ 求一份數據結構課程設計報告

//class CNode.h
#ifndef __CNODE_H__
#define __CNODE_H__

#include <iostream>
using namespace std;
struct stData //出生年月結構
{
int m_nYear;
int m_nMonth;
int m_nDay;
};

struct stResult //五門課成績結構
{
double m_dSubject_1; //自己改成績的名稱
double m_dSubject_2;
double m_dSubject_3;
double m_dSubject_4;
double m_dSubject_5;
};

struct stStudent //聲明學生信息的結構
{
string m_strNumber; //學生學號
string m_strName; //姓名
char m_chSex; //性別
struct stData m_stData; //出生年月
string m_strAppearance; //政治面貌
struct stResult m_stResult; //五門課成績
};

typedef class CNode
{
private:
struct stStudent m_stStudent;
CNode* m_Next;
public:
CNode(); //構造函數
~CNode(); //析構函數
void SetNodeData(); //設置結點內容的函數成員
stStudent GetNodeData(); //獲取結點內容的函數成員
void SetNodeNext(CNode* _Next); //設置結點Next指針的函數成員
void ShowNodeData(); //輸出結點內容的函數成員
CNode* GetNodeNext(); //獲取結點Next指針的函數成員
}LinkNode;

#endif

//class CLinkList
#ifndef __CLINKLIST_H__
#define __CLINKLIST_H__

#include "CNode.h"

typedef class CLinkList
{
private:
LinkNode* m_Head; //鏈表的頭指針
LinkNode m_Node; //鏈表的頭結點
public:
CLinkList(); //構造函數
~CLinkList(); //析構函數
void CreateList(); //初始化鏈表的函數成員
LinkNode* GetListNode(int _nIndex); //按位置查找指定位結點的成員函數
void InsertList(int _nIndex); //插入結點的成員函數
void DeleteList(int _nIndex); //刪除某一結點的成員函數
LinkNode* GetHeadList(); //獲取頭指針的成員函數
void SetListData(int _nIndex); //設置鏈表中某一結點的值的成員函數
void ShowListData(int _nIndex); //這個是現實鏈表中某一結點值的函數成員
void DestroyList(int _nIndex); //銷毀某一位置以後鏈表的成員函數
void ShowList(); //顯示鏈表的成員函數
}LinkList;

#endif

//class CLinkList

#include "CLinkList.h"
#include "CNode.h"

CLinkList::CLinkList()
{
cout << "這個是構造函數"<< endl;

m_Head = &m_Node; //鏈表的頭指針指向頭結點
m_Node.SetNodeNext(NULL); //將頭結點的Next指針設置為NULL;
}

CLinkList::~CLinkList()
{
cout << "這個是析構函數" << endl;
}

void CLinkList::CreateList() //以向後追加的方式創建一個鏈表，輸入0退出
{
int nTemp = 0; //定義一個臨時變數用於標志程序結束
cout << "歡迎來創建鏈表 !" << endl;
CNode * pTemp = NULL; //定義一個臨時結點指針，用來增加新結點用
CNode * pNode = m_Head; //定義一個標記指針，首先叫其指向頭結點

while(1)
{
pTemp = new LinkNode;

cout << "請輸入下一個結點的內容!" << endl;
pTemp->SetNodeData(); //設置鏈表中結點的內容

cout << "如果想繼續輸入下一個學生的信息請輸入 1，否則輸入 0" << endl;
cin >> nTemp;
if ('0' == nTemp)
{
break;
}
pNode->SetNodeNext(pTemp); //讓鏈尾的Next指向新建的結點
pNode = pTemp; //將結尾元素向後移
}
cout << "創建鏈表結束" << endl;
}

LinkNode* CLinkList::GetListNode(int _nIndex)
{
cout << "這個是按位置查找指定位結點的成員函數" << endl;

LinkNode* pNode = m_Head->GetNodeNext(); //定義一個臨時的結點指針,初始化指向頭結點
int Temp = 0; //定義一個臨時的變數，用來標記已檢查結點的個數的

if(-1 == _nIndex) //返回頭結點（即頭指針）
{
return m_Head;
}

if(_nIndex < -1) //_nIndex控制條件
{
cout << "您輸入的是錯誤的位置！" << endl;
return 0;
}

while(pNode != NULL)
{
if(_nIndex == Temp)
{
return pNode;
}
pNode = pNode->GetNodeNext(); //臨時結點向後移動
++Temp;
}

return pNode; //沒找到結點就返回NULL

}

void CLinkList::ShowListData(int _nIndex);

void CLinkList::InsertList(int _nIndex) //插入結點的函數成員
{
cout << "這個是插入結點的成員函數" << endl;

LinkNode* pNode = GetListNode(_nIndex - 1); //定義一個結點類的指針，指向的是要插入位置的前一指針

LinkNode* pTemp = new CNode; //定義一個臨時結點指針，用來增加新結點用

pTemp->SetNodeData(); //設置插入結點的內容

pTemp->SetNodeNext(pNode->GetNodeNext());
pNode->SetNodeNext(pTemp);
}

void CLinkList::DeleteList(int _nIndex)
{
cout << "這個是刪除某一結點的成員函數" << endl;

LinkNode* pNode = GetListNode(_nIndex - 1); //定義一個結點類的指針，指向的是要刪除位置的前一指針
LinkNode* pTemp = NULL; //定義一個臨時結點指針，用來指向要刪除的結點

pTemp =pNode->GetNodeNext(); //把pTemp指向要刪除的結點

pNode->SetNodeNext(pTemp->GetNodeNext()); //把pNode指向要刪除的結點的後一個結點

delete pTemp; //刪除結點
pTemp = NULL;
}

LinkNode* CLinkList::GetHeadList()
{
cout << "這個是獲取頭指針的成員函數" << endl;

return m_Head;
}

void CLinkList::SetListData(int _nIndex)
{
cout << "這個是設置鏈表中某一結點的值的成員函數" << endl;

CNode *pNode = GetListNode(_nIndex); //定義一個結點類的指針，指向的是要修改內容位置的結點

pNode->SetNodeData(); //修改內容

}

void CLinkList::ShowListData(int _nIndex)
{
cout << "這個是顯示鏈表中某一結點值的成員函數" << endl;

CNode *pNode = GetListNode(_nIndex); //定義一個結點類的指針，指向的是要獲取內容位置的結點

pNode->ShowNodeData(); //返回想要得到位置的結點內容
}

void CLinkList::DestroyList(int _nIndex)
{
cout << "這個是銷毀某一位置以後鏈表的成員函數" << endl;

LinkNode* pTemp = GetListNode(_nIndex - 1); //定義一個結點指針，指向要銷毀位置的前一結點
LinkNode* pNode = pTemp->GetNodeNext(); //定義一個結點指針，指向要銷毀位置的結點

while(pTemp->GetNodeNext() != NULL) //銷毀動作的結束條件或初始條件
{
pTemp->SetNodeNext(pNode->GetNodeNext()); //把需要銷毀的位置的前結點的Next指向銷毀位置的下一個結點
delete pNode; //銷毀結點

pNode = pTemp->GetNodeNext(); //把pNode重新指向要銷毀位置的結點
}
}

void CLinkList::ShowList()
{
cout << "這個是顯示鏈表的成員函數" << endl;

int nTemp = 0; //定義一個臨時的整形變數用來控制輸入的個數

LinkNode* pTemp = m_Head->GetNodeNext(); //定義一個結點類指針，指向第0位的結點
if(NULL == pTemp)
{
cout << "這是個空鏈" << endl;
}

while(pTemp != NULL)
{
pTemp->ShowNodeData();

++nTemp;
if(0 == nTemp % 5 && nTemp != 0) //控制每行只能輸出5個結點的內容
{
cout << endl;
}

pTemp = pTemp->GetNodeNext();
}
}

//class CNode
#include "CNode.h"

CNode::CNode() //構造函數
{
//m_stStudent = {0};
m_Next = NULL;
}

CNode::~CNode() //析構函數
{
}

void CNode::SetNodeData()
{
char* pNumber = new char[30]; //用來接收字元串的臨時變數
char* pName = new char[30];
char* pAppearance = new char[30];

cout << "學生學號: " << endl;
cin >> pNumber;
m_stStudent.m_strNumber = pNumber;
cout << "姓名: " << endl;
cin >> pName;
m_stStudent.m_strName = pName;
cout << "性別: " << endl;
cin >> m_stStudent.m_chSex;
cout << "出生年月: " << endl;
cout << "m_stData.m_nYear" << endl;
cin >> m_stStudent.m_stData.m_nYear;
cout << "m_stData.m_nMonth" << endl;
cin >> m_stStudent.m_stData.m_nMonth;
cout << "m_stData.m_nDay" << endl;
cin >> m_stStudent.m_stData.m_nDay;
cout << "政治面貌: " << endl;
cin >> pAppearance;
m_stStudent.m_strAppearance = pAppearance;
cout << "五門課成績: " << endl;
cout << "m_dSubject_1: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_1;
cout << "m_dSubject_2: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_2;
cout << "m_dSubject_3: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_3;
cout << "m_dSubject_4: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_4;
cout << "m_dSubject_5: " << endl;
cin >> m_stStudent.m_stResult.m_dSubject_5;

delete []pNumber; //釋放內存
pNumber = NULL; //指針置空

delete []pName; //釋放內存
pName = NULL;

delete []pAppearance; //釋放內存
pAppearance = NULL;
}

stStudent CNode::GetNodeData() //返回結點內容（即學生信息）
{
return m_stStudent;
}

void CNode::SetNodeNext(CNode* _Next)
{
m_Next = _Next;
}

void CNode::ShowNodeData()
{
const char* pNumber = m_stStudent.m_strNumber.c_str(); //用來接收字元串的臨時變數
const char* pName = m_stStudent.m_strNumber.c_str();
const char* pAppearance = m_stStudent.m_strAppearance.c_str();

cout << "學生學號: " << pNumber << '\t' << "姓名: " << pName << '\t' << "性別: " << m_stStudent.m_chSex;
cout << "出生年月: " << m_stStudent.m_stData.m_nYear << ',' << m_stStudent.m_stData.m_nMonth << ',' << m_stStudent.m_stData.m_nDay;
cout << "政治面貌: " << pAppearance << "五門課成績: " << endl;
cout << "m_dSubject_1: "<< m_stStudent.m_stResult.m_dSubject_1<< endl;
cout << "m_dSubject_2: "<< m_stStudent.m_stResult.m_dSubject_2<< endl;
cout << "m_dSubject_3: "<< m_stStudent.m_stResult.m_dSubject_3<< endl;
cout << "m_dSubject_4: "<< m_stStudent.m_stResult.m_dSubject_4<< endl;
cout << "m_dSubject_5: "<< m_stStudent.m_stResult.m_dSubject_5<< endl;

}

CNode* CNode::GetNodeNext()
{
return m_Next;
}

#include "CLinkList.h"
#include "CNode.h"

void Text(); //測試函數聲明

int main()
{
cout << "這是mian函數" << endl;
Text();
return 0;
}

void Text()
{
cout << "這個是測試函數" << endl;

LinkList* pList = new LinkList; //創建一個內存鏈表對象

cout << "------------------CreateList-----------------------------" << endl;
pList->CreateList(); //初始化鏈表的函數成員
pList->ShowList();
cout << endl;

cout << "------------------GetListNode-----------------------------" << endl;
LinkNode* pNode = NULL; //定義一個臨時的結點類指針用於檢測查找函數成員
pNode = pList->GetListNode(3); //按位置查找指定位結點的成員函數的測試

if(pNode)
{
cout << "用按位置查找的方法找到了指定位結點" << endl;
}
else
{
cout << "對不起，用按位置查找的方沒有找到指定位結點" << endl;
}
cout << endl;

cout << "------------------InsertList-----------------------------" << endl;
pList->InsertList(0); //插入結點的成員函數的測試
pList->ShowList();
cout << endl;

cout << "------------------DeleteList-----------------------------" << endl;
pList->DeleteList(0); //刪除某一結點的成員函數的測試
pList->ShowList();
cout << endl;

cout << "------------------GetHeadList-----------------------------" << endl;
pNode = NULL;
pNode = pList->GetHeadList(); //獲取頭指針的成員函數的測試
if(pNode)
{
cout << "已經返回了頭指針" << endl;
}
else
{
cout << "對不起，頭指針為空" << endl;
}
cout << endl;

cout << "------------------GetHeadList-----------------------------" << endl;
pList->SetListData(3); //設置鏈表中某一結點的值的成員函數的測試
pList->ShowList();
cout << endl;

cout << "------------------GetListData-----------------------------" << endl;
cout << "pList->ShowListData(3) =";
pList->ShowListData(3); //獲取鏈中某一結點值的成員函數的測試
cout << endl;

cout << "------------------DestroyList(3)-----------------------------" << endl;
pList->DestroyList(3); //銷毀第3位置以後鏈表的成員函數的測試
pList->ShowList();
cout << endl;

cout << "------------------DestroyList(0)-----------------------------" << endl;
pList->DestroyList(0); //銷毀第0位置以後鏈表的成員函數的測試
pList->ShowList();
cout << endl;

delete pList; //釋放內存
pList = NULL; //指針置空

}

你的要求太多 ， 沒仔細看， 我把我給別人寫的賦值給你吧 ， 我已經寫的很全了，程序有問題可以給我留言

❿ 數據結構與演算法課程設計——集合運算

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
struct set{
int coef;
struct set *next;
};

void createlist_p(struct set *&p,int n)
{
int i;
struct set *L;
p=(struct set *)malloc(sizeof(set));
p->next=NULL;
for(i=n;i>0;i--)
{
L=(struct set *)malloc(sizeof(set));
printf("請輸入該集合中第%d個整數元素:",n-i+1);
scanf("%d",&L->coef);
L->next=p->next;
p->next=L;
}
}//生成新鏈表用於存放兩集合中的元素
void printlist_p(struct set *&p)
{
struct set *L;
int i;
L=p->next;
if(!L) printf("該表為空!\n");
while(L!=NULL)
{
printf("%d ",L->coef);
L=L->next;
i++;
}
printf("\n");
}//列印輸入的兩集合中的元素
void Addset(struct set *&p,struct set *&q,struct set *&r)
{
struct set *k,*m,*n;
r=(struct set *)malloc(sizeof(set));
r->next=NULL;
k=p->next;
for(;k;)
{
m=(struct set *)malloc(sizeof(set));
m->next=r->next;
r->next=m;
m->coef=k->coef;
k=k->next;
}//把第一個集合中的元素放在新集合中
k=q->next;
m=(struct set *)malloc(sizeof(set));
m->next=r->next;
r->next=m;
m->coef=k->coef;
k=k->next;
for(;k;)
{
for(n=r->next;(k->coef!=n->coef)&&n->next;){
n=n->next;
}//與新集合中的元素比較
if((k->coef!=n->coef)&&!(n->next)){
m=(struct set *)malloc(sizeof(set));
m->next=r->next;
r->next=m;
m->coef=k->coef;
}
k=k->next;
}//對第二個集合中的元素進行分析

}//求A∪B
void Subset(struct set *&p,struct set *&q,struct set *&r){
struct set *k,*m,*n;
r=(struct set *)malloc(sizeof(set));
r->next=NULL;
n=q->next;
for(;n;){
m=p->next;
for(;(m->coef!=n->coef)&&m->next;){
m=m->next;
}
if(m->coef==n->coef) {
k=(struct set *)malloc(sizeof(set));
k->next=r->next;
r->next=k;
k->coef=m->coef;
}
n=n->next;
}

}//求A∩B
void Intset(struct set *&p,struct set *&q,struct set *&r){
struct set *k,*m,*n;
r=(struct set *)malloc(sizeof(set));
r->next=NULL;
m=p->next;
for(;m;){
n=q->next;
for(;(m->coef!=n->coef)&&n->next;){
n=n->next;
}
if(!n->next&&(m->coef!=n->coef)) {
k=(struct set *)malloc(sizeof(set));
k->next=r->next;
r->next=k;
k->coef=m->coef;
}
m=m->next;
}
}//求A-B
void bangzhu(){
printf("\n\t\t\t***********************************");
printf("\n\t\t\t* 求集合的交並差 *");
printf("\n\t\t\t*********************************\n");
}
void main()
{
struct set *p,*q,*r;
int m,n,node;
bangzhu();

for(;;)
{
do{
printf("請輸入您要選擇操作的代碼:\n");
printf("1：求兩集合的並A∪B\n");
printf("2：求兩集合的交A∩B\n");
printf("3：求兩集合的差A-B\n");
printf("0：退出該程序\n");
scanf("%d",&node);
} while(node<0||node>3);

if(node==0) exit(1);
printf("\t\t\t/*請輸入集合A中元素的個數：*/\n");
scanf("%d",&m);
createlist_p(p,m);
printf("\t\t\t/*請輸入集合B中元素的個數：*/\n");
scanf("%d",&n);
createlist_p(q,n);
printf("集合A中元素為:");
printlist_p(p);
printf("集合B中元素為:");
printlist_p(q);
while(node<0||node>3);
switch(node)
{
case 1: Addset( p,q,r);printf("A∪B:\n");printlist_p(r);break;
case 2: Subset( p,q,r);printf("A∩B:\n");printlist_p(r);break;
case 3: Intset(p,q,r); printf("A-B:\n");printlist_p(r);break;
}
printf("\n");
}
}
可以了
樓上方法是正確的，學習!把分給樓上