数据结构学习第八天

18:35:51 2019-08-23

学习

 16:55:15 2019-08-24

补充了 插值查找

 无序向量的操作 以及  有序向量 二分查找  Fibonacci查找

#define _CRT_SECURE_NO_WARNINGS    //vs中scanf为不安全的函数 要使用 得加上这句话
#include<stdio.h>
#define Size 10
int Vector[10] = { 1,6,8,9,11,15,18,33,40,61 };
//int Vector[Size];
// 无序向量
int GetElement(int Rank)  //按秩访问元素 
{
    if (Rank < Size)
        return Vector[Rank];
    else
        return -1;
}
void Insert(int Rank, int Element) //按秩插入元素
{
    if (Rank < Size)
    {
        for (int i = Size - 1; i >Rank; i--)
        {
            Vector[i] = Vector[i - 1];
        }
        Vector[Rank] = Element;
    }
}
int Delete(int lo, int hi)  //区间删除 单元素删除时区间删除的特列
{
    for (;hi< Size;)
        Vector[lo++] = Vector[hi++];
    return hi - lo;
}
int Find(int Element,int lo,int hi)  //在范围中查找元素
{
    while (lo<hi-- && Vector[hi] != Element);
    return hi;
} 
int  DeleteOne(int Rank)   //单元素删除
{
    Delete(Rank, Rank + 1);
    return Vector[Rank];
}
void DeDuplicate() //无序向量的唯一化   低效版
{
    int i = 0;
    while (i<Size)
    {
        Find(Vector[i], 0, i) > 0 ? DeleteOne(i) : i++;
    }
}


//有序向量
void LowDuplicate() // 有序向量的唯一化   低效版  O(n^2)
{
    int i = 0;
    while (i<Size)
    {
        (Vector[i] == Vector[i + 1]) ? DeleteOne(i+1) : i++;
    }
}

int HighDuplicate()   //有序向量的唯一化  高效版  O(n)
{
    /*int i = 0;
    int j = 1;
    while (i<Size)
    {
        if (Vector[i] == Vector[j])
            j++;
        Delete(i + 1, j + 1);
        i = j+1;
    }*/ //错误写法 利用delete(lo,hi)并不能达到高效率 
    //直接从后面截取
    int i = 0;
    int j = 0;
    while (j < Size)
    {
        if (Vector[i] != Vector[j])
            Vector[++i] = Vector[j];
        else
            j++;
    }
    //int size = ++i; shrink();   //直接删除掉尾部的多余元素
    return j - i;// 返回删除元素总数
    /*上面这个可写成
    int i=0,j=0;
    while(++j<size)
    {
        if(Vector[i]!=Vector[j])
            Vector[++i]=Vector[j];
    }
    */
}

//二分查找     O(LogN)   //减而治之
//下面三个版本A
/*int BinarySearch(int Element, int lo, int hi) //二分查找1  对特殊情况未做处理    //左右转向代价不平衡
{
    while (lo<=hi)
    {
        int i = (lo + hi) / 2;
        if (Element < Vector[i])
            hi = i-1;
        else if(Element>Vector[i])
            lo = i+1;
        else
            return i;
    }
    return -1;
}*/
/*int BinarySearch(int Element, int lo, int hi)     //二分查找2  对特殊情况处理不够好
{
    if (lo >= hi)
        return hi;
    int i = (lo + hi) / 2;
    if (Element < Vector[i])
        return BinarySearch(Element, lo, i-1);
    else if (Element > Vector[i])
        return BinarySearch(Element, i+1, hi);
    else
        return i;
}*/
/*int BinarySearch(int Element, int lo, int hi)  //二分查找3 邓公实现方式 我未完善
{
    
    while (lo<hi)
    {
        int i = (lo + hi) >> 1;     // 位运算比乘除法快
        if (Element < Vector[i])
            hi = i;
        else if (Vector[i] < Element)
            lo = i + 1;
        else
            return i;
    }
    return -1; 
}*/            //上面三个思路都是一样的 选取中间为切分点(轴点)

/*int BinarySearch(int Element, int lo, int hi)    //版本B 二分查找改进版 将判断从三个改为两个 牺牲刚好命中节点的情况 来换取左右每次转向的代价平衡
{                                                //相较于上面的版本 这种算法在最好(坏)的情况下更坏(好)
    /*while (1<hi-lo)                            //各种情况下的SL(search length？)更加接近 整体性能趋于稳定
    {
        int i = (lo + hi) / 2;
        if (Element < Vector[i])
            hi = i;
        else
            lo = i;
    }
    if (Element == Vector[lo])
        return lo;
    else
        return -1;*/
    //上面这个可写成
    /*while(1 < hi - lo)
    {
        int i = (lo + hi)>>1;
        (Element < Vector[i]) ? hi = i : lo = i;
    }
    return (Element == Vector[lo]) ? lo :-1;
}*/

int BinarySearch(int Element, int lo, int hi)      //版本C 满足了找到不大于元素Element的最大秩
{
    while (lo<hi)
    {
        int i = (lo + hi) / 2;
        (Element < Vector[i]) ? hi = i : lo = i + 1;     //对于小于所有数组内值 的元素 i会变为0
                                                        //对于大于所有数组内值  的元素 i会变为Size
                                                        //对于大于某一部分数组内值 的元素 i最终会变为 该数组元素下标加一
    }
    return --lo;          
}

//Fibonacci查找算法    //使向左的操作变多 向右的操作变少   O(logN)
//Fibonacci 查找的算法的 ASL(average searth length  平均查找长度) (在常数意义上)优于二分查找
void Fibonacci(int* F,int size) 
{
    F[0] = F[1] = 1;
    for (int i = 2; i < size; i++)
            F[i] = F[i - 1] + F[i - 2];
}    
/*int FibonacciSearch(int Element,int lo,int hi) //这个做法补全了元素 是得任意的数组都可以满足Fibonacc查找的条件
{
    int fib[Size];
    Fibonacci(fib, Size);
    int k = 0;
    while (hi > fib[k]-1)               //找到以个Fibonacc的元素使其减一后大于等于元素总数
        k++;
    for (int i = hi; hi < fib[k] - 1; i++)     //补全数组 使数组依旧有序
        Vector[i] = Vector[hi - 1];
    while (lo<hi)
    {
        int i = (lo + fib[k - 1] - 1);              //选取的位置
        if (Element < Vector[i])
        {
            hi = i;
            k -= 1;                         //在左侧的话减一
        }
        else if (Vector[i] < Element)
        {
            lo = i + 1;
            k -= 2;                            //在右侧的话减二
        }
        else
            return i;
    }
    return -1;
}*/
int FibonacciSearch(int Element, int lo, int hi)   //这个更加容易理解 利用切分点对有序向量进行划分
{                                                    //利用Fibonacc数列分割 使得每次向左操作数多一点  因为向左只需要比较一次
    int fib[Size];
    Fibonacci(fib, Size);
    int k = 19;
    while (lo<hi)
    {
        while (hi - lo < fib[k])      //找到一个Fibonacc数列某个元素使其 尽可能刚好小于 数组元素总数  
                k--;                //这就是不断找到可以用来分割 数组的 Fibonacc数列的元素
        int i = lo + fib[k] - 1;
        if (Element < Vector[i])
            hi = i;
        else if (Vector[i] < Element)
            lo = i + 1;
        else
            return i;
    }
    return -1;

}

//插值查找      //假设已知有序向量中各元素随机分布的规律    O(loglogN)  小写的o

//比如均匀且独立的分布   当然这是最为简单的一种情况
//这时候 数组中的元素按线性趋势增长
//平均情况:每经过一次比较 n缩至根号n
int InterpolationSearch(int Element,int lo,int size)     
{
    int hi = size - 1;                       //与二分查找 Fibonacc查找不同的是  插值查找的左边界被包含在内
    while (lo<hi)                            //因为计算是需要用秩访问最后一个元素
    {
        int i = lo + (hi - lo) * (Element - Vector[lo]) / (Vector[hi] - Vector[lo]);    //线性趋势增长的规律
        //(Element < Vector[i]) ? hi = i : lo = i + 1;
        if (i > size - 1)
            return size - 1;
        if (Element < Vector[i])
            hi = i;
        else if (Element > Vector[i])
            lo = i + 1;
        else
            return i;
    }
    return --lo;
}
// 插值查找对于处理较大数据时具有的优势更大
//因此应该先用插值查找将范围缩小的一定范围 再进行二分查找
int main()
{
    /*for (int i = 0; i < Size; i++)
    {
        printf("%d ", Vector[i]);
    }
    printf("
");
    int Element=0;
    while(scanf("%d", &Element))
        printf("%d
",BinarySearch(Element, 0, Size));  //二分查找*/
    /*for (int i = 0; i < 7; i++)
    {
        printf("%d ", Vector[i]);
    }
    int Element = 0;
    printf("
");
    while (scanf("%d", &Element))
        printf("%d
", FibonacciSearch(Element, 0, 7));   //Fibonacc查找  */
    for (int i = 0; i < Size; i++)
        {
            printf("%d ", Vector[i]);
        }
        printf("
");
        int Element=0;
        while(scanf("%d", &Element))
            printf("%d
",InterpolationSearch(Element, 0, Size));  //插值查找
}

以前写代码时写注释写的少   。。导致现在注释写的很难看。。。。