数据结构实验报告四

1.折半查找算法

1）问题描述：从键盘读入一串整数和一个待查关键字，查找在该整数串中是否有这个待查关键字。如果有，输出它在整数串中的位置；如果没有，输出-1

2）实验要求：

• 利用折半查找算法查找
• 用递归和非递归两种方式实现折半查找算法

3) 实现提示：

• 递归实现参考书上折半查找算法的实现
• 非递归算法利用栈实现

#include<iostream>
#include<algorithm>
using namespace std;
int search(int s[],int key,int n){
	int low=1,high=n;
	int mid;
	while(low<=high){
		mid = (low+high)/2;
		if(s[mid] == key) return mid;
		else if(key<s[mid]){
			high = mid - 1;
		}
		else low = mid + 1;
	}
	return -1;
} 
int main(){
	int s[100],s1[100],i=1,k,n,n1;
	cout<<"输入元素个数和要查找元素"<<endl;
	cin>>n>>k;
	n1=n;
	while(n1--){
		cin>>s[i++]; 
		s1[i-1] = s[i-1];
	}
	sort(s1+1,s1+n+1);
	n1 = search(s1,k,n);
	cout<<"查找结果："<<endl; 
	if(n1==-1) cout<<-1;
	else{
	    for(i=1;i<=n;i++){
	    	if(s1[n1] == s[i]){
		    	cout<<i;
		    }
	    }		
	}
	return 0;
}

2.构造二叉排序树，并进行中序遍历

1）问题描述：从键盘读入一串整数构造一棵二叉排序树，并对得到的二叉排序树进行中序遍历，得到有序序列。

2）实验要求：该二叉排序树以二叉链表存储

3）实现提示：二叉排序树的构成，可从空的二叉树开始，每输入一个结点数据，就建立一个新结点插入到当前已生成的二叉排序树中，所以它的主要操作是二叉排序树插入运算。在二叉排序树中插入新结点，只要保证插入后仍符合二叉排序树的定义即可。

#include<iostream>
#include<cstdlib>
using namespace std;
typedef struct BiTree{
	int data;
	BiTree* lchild;
	BiTree* rchild;
}; 
typedef BiTree* BT;
void insert(BT &T,int k){
	if(T==NULL){
		T = (BiTree*)malloc(sizeof(BiTree));
		T->data = k;
		T->lchild = T->rchild = NULL;
	}
	else if(k<=T->data) insert(T->lchild,k);
	else if(k>T->data) insert(T->rchild,k);
}
int count=0,count1=1;
void inOrder(BiTree* T){
	if(T == NULL) return;
	inOrder(T->lchild);
	if(count<count1){
	    cout<<T->data<<" ";
	    count++;		
	}
    else{
    	cout<<T->data;
	}
	inOrder(T->rchild);
}
int main(){
	BiTree* T = NULL; int k;
	cin>>k;
	while(k!=-1){
		insert(T,k);
		cin>>k;
		count1++;
	}
	cout<<"中序遍历结果为:"<<endl;
	inOrder(T);	
	return 0;
}

3. 对于给定的一个有序序列，创建一颗高度最小的二叉排序树。

1）实验要求：该二叉排序树以二叉链表存储

2）实验提示：要创建一颗高度最小的二叉排序树，就必须让左右子树的节点个数越接近越好。由于给定的是一个关键字有序序列a[start..end]，所以让其中间位置的关键字a[mid]作为根结点，左序列a[start..mid-1]构造左子树，右序列a[mid+1..end]构造右子树。

#include <iostream>
#define LH 1
#define EH 0
#define RH -1
using namespace std;
typedef struct AVLNode{
    int data;
    int bf;
    AVLNode *lchild;
	AVLNode *rchild;
}AVLNode,*AVLTree;
int H(AVLTree &T,int height)
{
    if(T==NULL) return 0;
    else{
    	height=max(H(T->lchild,height),H(T->rchild,height))+1;
        return height; 
    }
}
void rotate_left(AVLTree &p)            
{
    AVLTree rightchild=p->rchild;
    p->rchild=rightchild->lchild;
    rightchild->lchild=p;
    p=rightchild;
}
void rotate_right(AVLTree &p)         
{
    AVLTree leftchild=p->lchild;
    p->lchild=leftchild->rchild;
    leftchild->rchild=p;
    p=leftchild;
}
void LR(AVLTree &p)                  
{
    rotate_left(p->lchild);
    rotate_right(p);
}
void RL(AVLTree &p)                   
{
    rotate_right(p->rchild);
    rotate_left(p);
}
void LeftBalance(AVLTree &p)
{
    AVLTree lchild = p->lchild;
    AVLTree rchild = NULL;
    switch(lchild->bf)
    {
        case LH:       
            p->bf=lchild->bf=EH;
            rotate_right(p);
            break;
        case EH:          
            break;
        case RH:              
            rchild=lchild->rchild;
            switch(rchild->bf)
        {
            case LH:          
                p->bf=RH;
                lchild->bf=EH;
                break;
            case EH:
                p->bf=lchild->bf=EH;
                break;
            case RH:
                p->bf=EH;
                lchild->bf=LH;
                break;
        }
            rchild->bf=EH;
            rotate_left(p->lchild);
            rotate_right(p);
    }
}

void RightBalance(AVLTree &p)
{
    AVLTree rchild=p->rchild;
    AVLTree lchild=NULL;
    switch(rchild->bf)
    {
        case RH:
            p->bf=rchild->bf=EH;
            rotate_left(p);
            break;
        case EH:
            break;
        case LH:
            lchild=rchild->lchild;
            switch(lchild->bf)
        {
            case LH:
                p->bf=EH;
                rchild->bf=RH;
                break;
            case EH:
                p->bf=rchild->bf=EH;
                break;
            case RH:
                p->bf=LH;
                rchild->bf=EH;
                break;
        }
            lchild->bf=EH;
            rotate_right(p->rchild);
            rotate_left(p);
    }
}

int InsertAVL(AVLTree &T,int e,int &taller)
{
    if(!T)
    {
        T=new AVLNode;
        T->data=e;
        T->lchild=T->rchild=NULL;
        T->bf=EH;
        taller=1;
    }
    else if(e==T->data)
    {
        taller=0;          
        return 0;
    }
    else if(e<T->data){     
        if(!InsertAVL(T->lchild,e,taller))
            return 0;
        if(taller)
            switch(T->bf){
                case LH:
                    LeftBalance(T);
                    taller=0;
                    break;
                case EH:
                    T->bf=LH;
                    taller=1;
                    break;
                case RH:        
                    T->bf=EH;
                    taller=0;
                    break;
            }
    }
    else if(e>T->data)
    {
        if(!InsertAVL(T->rchild,e,taller))
            return 0;
        if(taller)
            switch(T->bf)
        {
            case RH:
                RightBalance(T);
                taller=0;
                break;
            case EH:
                T->bf=RH;
                taller=1;
                break;
            case LH:
                T->bf=EH;
                taller=0;
                break;
        }
    }
    return 1;
}
int main()
{
    AVLTree T = NULL;
    int t,k,t1=0;
    cin>>k;
    while(k!=-1)
    {
        InsertAVL(T,k,t);
        cin>>k;
    }
    cout<<"最小高度为："<<endl;
    cout<<H(T,t1);
    return 0;
}