数据结构拾遗——查找

这一章内容好多，总结了好久

#pragma once
#include <vector>
using namespace std;
template <class T>
int SequentialSearch(const vector<T> &v, T key) {
    int answer = 0;
    for (auto i : v)
    {
        if (key == i)
            break;
        answer++;
    }
    return answer;
}

#pragma once
#pragma once
#include <vector>
using namespace std;

template <class T>
int compareT(T t1,T t2) {
    if (t1 == t2)
        return 0;
    else
    {
        if (t1 < t2)
            return -1;
        else
            return 1;
    }
}
template <class T>
int BinarySearch(const vector<T> &v, T key) {
    int low = 0, high = v.size() - 1, mid;
    while (low <= high)
    {
        mid = (low + high) / 2;
        switch (compareT(key,v[mid]))
        {
        case 0:
            return mid;
        case 1:
            low = mid + 1;
            break;
        case -1:
            high = mid - 1;
            break;
        }
    }
    return v.size();
}

template <class T>
int InterpolationSearch(const vector<T> &v, T key) {
    int low = 0, high = v.size() - 1, mid;
    while (low <= high)
    {
        mid = low + (key - v[low]) / (v[high] - v[low])*(high-low);
        switch (compareT(key, v[mid]))
        {
        case 0:
            return mid;
        case 1:
            low = mid + 1;
            break;
        case -1:
            high = mid - 1;
            break;
        }
    }
    return v.size();
}

#pragma once
#include <iostream>
using namespace std;

struct BiTNode
{
    int data;
    struct BiTNode *lchild, *rchild;
};


void MiddleRoot(const BiTNode const *T) {
    if (T)
    {
        if (T->lchild)
            MiddleRoot(T->lchild);

        cout << T->data << " ";

        if (T->rchild)
            MiddleRoot(T->rchild);
    }
}

void FirstRoot(const BiTNode const *T) {
    if (T)
    {
        cout << T->data << " ";

        if (T->lchild)
            FirstRoot(T->lchild);

        if (T->rchild)
            FirstRoot(T->rchild);
    }
}

void LastRoot(const BiTNode const *T) {
    if (T)
    {
        if (T->lchild)
            LastRoot(T->lchild);

        if (T->rchild)
            LastRoot(T->rchild);

        cout << T->data << " ";
    }
}

/*
创建时间
20170419
说明
二叉排序树练习
*/
#pragma once
#include "BinaryTree.h"

int SearchBST(BiTNode *Tree, int key, BiTNode *f, BiTNode **p) {
    if (!Tree)
    {
        *p = f;
        return 0;
    }
    else if (key == Tree->data)
    {
        *p = Tree;
        return 1;
    }
    else if (key < Tree->data)
        return SearchBST(Tree->lchild, key, Tree, p);

    else
        return SearchBST(Tree->rchild, key, Tree, p);
}

int InsertBST(BiTNode **Tree, int key) {
    BiTNode *p, *s;
    if (!SearchBST(*Tree,key,NULL,&p))
    {
        s = (BiTNode*)malloc(sizeof(BiTNode));
        s->data = key;
        s->lchild = s->rchild = NULL;
        if (!p)
            *Tree = s;
        else if (key<p->data)
            p->lchild = s;
        else
            p->rchild = s;
        return 1;
    }
    else
    {
        return 0;
    }
}

int Delete(BiTNode **p) {
    BiTNode *q, *s;
    if ((*p)->rchild == NULL)
    {
        q = *p;
        *p = (*p)->lchild;
        free(q);
    }
    else if ((*p)->lchild == NULL)
    {
        q = *p;
        *p = (*p)->rchild;
        free(q);
    }
    else
    {
        q = *p;
        s = (*p)->lchild;
        while (s->rchild)
        {
            q = s;
            s = s->rchild;
        }
        (*p)->data = s->data;
        //Delete(&s);
        if (q!=*p)
        {
            q->rchild = s->lchild;
        }
        else
        {
            q->lchild = s->lchild;
        }
        free(s);
    }
    return 1;
}

int DeleteBST(BiTNode **T, int key) {
    if (!T)
        return 0;

    else 
    {
        if ((*T)->data == key)
            return Delete(T);

        else if (key < (*T)->data)
            return DeleteBST(&(*T)->lchild, key);

        else
            return DeleteBST(&(*T)->rchild, key);
    }
}

#pragma once
#include <iostream>
using namespace std;

struct BiTNode_avl
{
    int data;
    int bf;
    struct BiTNode_avl *lchild, *rchild;
};

void R_Rotate(BiTNode_avl **p) {
    BiTNode_avl *L;
    L = (*p)->lchild;
    (*p)->lchild = L->rchild;
    L->lchild = (*p);
    *p = L;
}

void L_Rotate(BiTNode_avl **p) {
    BiTNode_avl *R;
    R = (*p)->rchild;
    (*p)->lchild = R->lchild;
    R->lchild = (*p);
    *p = R;
}

#define  LH +1
#define  EH 0
#define  RH -1

void LeftBalance(BiTNode_avl **T) {
    BiTNode_avl *L, *Lr;
    L = (*T)->lchild;
    switch (L->bf)
    {
    case LH:
        (*T)->bf = L->bf = EH;
        R_Rotate(T);
        break;
    case RH:
        Lr = L->rchild;
        switch (Lr->bf)
        {
        case LH:
            (*T)->bf = RH;
            L->bf = EH;
            break;
        case EH:
            (*T)->bf = L->bf = EH;
            break;
        case RH:
            (*T)->bf = EH;
            L->bf = LH;
            break;
        }
        Lr->bf = EH;
        L_Rotate(&(*T)->lchild);
        R_Rotate(T);
    }
}

int InsertAVL(BiTNode_avl **T, int e, int *taller) {
    if (!*T)
    {
        *T = (BiTNode_avl *)malloc(sizeof(BiTNode_avl));
        (*T)->data = e;
        (*T)->lchild = (*T)->rchild = NULL;
        (*T)->bf = EH;
        *taller = true;
    }
    else
    {
        if (e == (*T)->data)
        {
            *taller = false;
            return false;
        }
        if (e < (*T)->data)
        {
            if (!InsertAVL(&(*T)->lchild,e,taller))
            {
                return false;
            }
            if (taller)
            {
                switch ((*T)->bf)
                {
                case LH:
                    LeftBalance(T);
                    *taller = false;
                    break;
                case EH:
                    (*T)->bf = LH;
                    *taller = true;
                    break;
                case RH:
                    (*T)->bf = EH;
                    *taller = false;
                    break;
                }
            }
        }
        else
        {
            if (!InsertAVL(&(*T)->rchild,e,taller))
            {
                return false;
            }
            if (*taller)
            {
                switch ((*T)->bf)
                {
                case LH:
                    (*T)->bf = EH;
                    *taller = false;
                    break;
                    
                case EH:
                    (*T)->bf = RH;
                    *taller = true;
                    break;
                case RH:
                    RightBalance(T);
                    *taller = false;
                    break;
                }
            }
        }
    }
    return true;
}