各种查找算法效率比较

最新推荐文章于 2024-08-17 20:04:47 发布

mfcheer

最新推荐文章于 2024-08-17 20:04:47 发布

阅读量4.9k

点赞数 2

分类专栏： ----------杂各种课设文章标签：数据结构算法

本文链接：https://blog.csdn.net/u014427196/article/details/44598923

版权

本文对比分析了三种查找算法——折半查找、平衡二叉排序树查找及B-树查找在已排序整数序列中的效率。在最坏情况下，详细探讨了每种算法的时间复杂度，并针对不同规模的数据集（N=100至10000）进行了性能测试，包括计算ASL（Average Search Length）和运行时间的平均值，通过绘制曲线图来验证理论与实际运行时间的匹配度。

摘要由CSDN通过智能技术生成

题目描述：
给定一个已经排好序的N个整数的序列（数据从1到N），在该序列中查找指定的整数，并观察不同算法的运行时间。考查3类查找算法：折半查找，平衡二叉排序树的查找，B-树的查找。
要求：
（1）构造树表的算法要考虑各种可能的输入数据序列；
（2）可根据要求输出树表结构；
（3）分析最坏情况下，三种查找算法的复杂度；
（4）测量并比较三种算法在N=100，500，1000，2000，4000，6000，8000，10000时的性能，要求完成以下三个方面的工作：
① 对每个测试数据集，统计计算每种查找算法的ASL；
② 对每个测试数据集运行多次获得运行时间的平均值；
③ 绘制算法实际运行结果（ASL和运行时间）的曲线图，验证和理论分析的时间复杂度的吻合性。

#include<iostream>
#include<stdio.h>
#include <time.h>
#include <malloc.h>

using namespace std;

#define CLOCKS_PER_SEC ((clock_t)1000)
#define MaxSize 100002
#define M 100
int Step;
int Bjishu;
using namespace std;

typedef struct
{
    int key;

}DataType;
typedef struct
{
    DataType list[MaxSize];
    int size;
}SeqList;

typedef struct node
{
    DataType data;
    struct node *LeftChild;//
    struct node *RightChild;//
    struct node *Parent;
    int i;//height
}BITreeNode, BTnode, *Tree;//二叉平衡树结构体

typedef struct Node
{
    struct Node *parent;        /*指向双亲结点*/
    int key[M];              /*关键字向量，0号单元未用(M-1阶)*/
    struct Node *ptr[M];        /*子树指针向量*/
}B_TNode;//B_树结构体


void ListInitiate(SeqList *L)
{
    L->size = 0;
}
int ListLength(SeqList L)
{
    return L.size;
}
int ListInsert(SeqList *L, int x)
{
    // int j;
    if (L->size >= MaxSize)
    {
        printf("顺序表已满\n");
        return 0;
    }
    else
    {
        //for(j=L->size;j>i;j--)L->list[j]=L->list[j-1];
        L->list[L->size].key = x;
        L->size++;
        return 1;
    }
}
int BInarySearch(SeqList S, DataType x)//折半查找
{
    int js = 1;                        //次数记录
    int low = 0;
    int high = S.size - 1;
    int mid;
    while (low <= high)
    {
        mid = (low + high) / 2;             //中间位置
        if (S.list[mid].key == x.key)return js;
        else if (S.list[mid].key<x.key)low = mid + 1;
        else if (S.list[mid].key>x.key)high = mid - 1;
        js++;
    }
    return -1;
}
int Hetree(BTnode *Root)
{
    if (Root == NULL)return 0;
    return
        Hetree(Root->LeftChild)>Hetree(Root->RightChild) ? Hetree(Root->LeftChild) + 1 : Hetree(Root->RightChild) + 1;
}


int IsBlance(BTnode *Root)//判断二叉树的平衡)
{
    int bf;
    if (Root != NULL)
    {
        bf = Hetree(Root->LeftChild) - Hetree(Root->RightChild);
        if ((bf<-1) || (bf>1))
            return 0;//不平衡
        else
        {
            if (IsBlance(Root->LeftChild) && IsBlance(Root->RightChild))
                return 1;