数据结构课程设计(8)

int _tmain(int argc, _TCHAR* argv[]) {

int key; BSTree t;

printf(\创建二叉树：\\n\); createBST(t);

printf(\中序遍历二叉树:\);

InOrder(t);

printf(\输入你要删除结点的关键字：\\n\); scanf_s(\,&key); t=deleteBST(t,key); if(t==NULL)

printf(\对不起，你所删除的结点%d不存在!\\n\,key); else

printf(\成功删除结点%d.\\n\,key); printf(\中序遍历二叉树:\); }

InOrder(t); system(\) ; return 0;

24、设定哈希函数 H(key) = key MOD 11 ( 表长=11 )，输入一组关键字序列，根据线性探测

再散列解决冲突的方法建立哈希表的存储结构，显示哈希表，任意输入关键字，判断是否在哈希表中。

#include \ #include \ #include \ #include \

typedef struct {

typedef struct SQList {

void Insert(SQList &s , int i) {

int a = i % 11 ; if(s.elem[a].data == 0)

s.elem[a].data = i ; elemtype * elem ; }SQList ;

int data ; }elemtype ;

}

else { }

while(s.elem[a].data != 0) { }

s.elem[a].data = i ;

if(a == 11)

a = 1 ; a = a + 1 ; else

void Print(SQList s) { }

int Search(SQList s , int a) { }

int _tmain(int argc, _TCHAR* argv[]) {

SQList s ; int a ;

s.elem = (elemtype *)malloc(12*sizeof(elemtype)) ; for(int i = 1 ; i <= 11 ; i++)

s.elem[i].data = 0 ;

printf(\请依次输入要插入的数据：\) ; for(int i = 0 ; i < 11 ; i++) { }

scanf_s(\,&a) ; Insert(s , a) ;

for(int i = 1 ; i <= 11 ; i++)

if(a == s.elem[i].data)

return 1 ;

printf(\哈希表存储如下：\) ; for(int i = 1 ; i <= 11 ; i++) { }

printf(\,s.elem[i].data) ;

return 0 ;

}

Print(s) ; system(\) ; return 0;

排序

以下问题要求统一在一个大程序里解决。 25、折半插入排序 26、冒泡排序 27、快速排序

28、简单选择排序 29、归并排序 30、堆排序

#include \ #include \ #include \

typedef struct {

typedef struct SQList {

void Create(SQList &s) { }

void Print(SQList s) {

printf(\线性表输出如下：\\n\); printf(\请输入数字个数：\\n\) ; scanf_s(\,&s.len ) ;

s.elem = (elemtype *)malloc((s.len+1)*sizeof(elemtype)) ; printf(\请依次输入数字：\\n\) ; for(int i = 1 ; i <= s.len ; i++) { }

printf(\第%d个数字：\,i);

scanf_s(\,&(s.elem[i].data)) ; elemtype * elem ; int len ; int data ; }elemtype ;

}SQList ;

} { }

for(int i = 1 ; i <= s.len ; i++)

printf(\,s.elem[i].data) ;

void zheban(SQList &L)

int i,low,high,m,j; for(i=2;i<=L.len;++i) { }

L.elem[0]=L.elem[i]; low=1; high=i-1; while(low<=high) { }

for(j=i-1;j>=high+1;--j)

L.r[j+1]=L.r[j];//记录后移 L.r[high+1]=L.r[0];//插入

m=(low+high)/2;

if(L.elem[0].key

high=m-1; else low=m+1;

void 冒泡排序(SQList &s) { }

int i = s.len ; while(i > 1) { }

int last = 1 ;

for(int j = 1; j < i ; j++) { }

i = last ;

if(s.elem[j].data > s.elem[j+1].data) { }

s.elem[0] = s.elem[j+1] ; s.elem[j+1] = s.elem[j] ; s.elem[j] = s.elem[0] ; last = j ;

int Partition (SQList &s , int low , int high) { }

void 快速排序(SQList &s , int i , int j) { }

int SelectMindata(SQList s , int i) { }

void 简单选择排序(SQList &s) {

for(int i = 1 ; i < s.len ; i++) {

int j = SelectMindata(s,i) ; int MK = i ;

for(int j = i ; j <= s.len ; j++) { }

return MK;

if(s.elem[j].data < s.elem[MK].data)

MK = j ;

if(i < j) { }

int pivotloc = Partition(s,i,j) ; 快速排序(s , i , pivotloc-1) ; 快速排序(s , pivotloc+1 , j) ; s.elem[0]=s.elem[low] ;

int pivotloc = s.elem[low].data; while(low

s.elem[low] = s.elem[0] ; return low ;

while(low < high&&s.elem[high].data >= pivotloc)

high-- ;

s.elem[low] = s.elem[high];

while(low < high&&s.elem[low].data <= pivotloc)

low++ ;

s.elem[high] = s.elem[low] ;