1.二分查找和插值查找 
//************************Search.h***********************************
#ifndef SEARCH_H
#define SEARCH_H#include <stdio.h>
#include <stdlib.h>int BiSearch(int array[],int n,int key);int IVSearch(int array[],int n,int key);int FibSearch(int array[],int n,int key);#endif //SEARCH_H//************************Search.c*************************************
#include "Search.h"//折半查找
int BiSearch(int array[],int n,int key)
{if(NULL == array)return -1;int left = 0;int right= n-1;int mid  = (left+right)/2;while(left <= right){if(array[mid] == key){return mid;}else if(array[mid] > key){right = mid-1;}else if(array[mid] < key){left = mid+1;}mid = (left+right)/2;}return -1;
}//插值查找
int IVSearch(int array[],int n,int key)
{if(NULL == array)return -1;int left = 0;int right= n-1;int mid  = left+(right-left)*(key-array[left])/(array[right]-array[left]);while(left <= right){if(array[mid] == key){return mid;}else if(array[mid] > key){right = mid-1;}else if(array[mid] < key){left = mid+1;}mid  = left+(right-left)*(key-array[left])/(array[right]-array[left]);}return -1;
}int FibSearch(int array[],int n,int key)
{int F[] = {1,1,2,3,5,8,13,21,34,55,89};int left = 0;int right= n-1;int mid;int k = 0;while(n>F[k]-1){k++;}for(int i=n;i < F[k])}//************************SearchTest.c*************************************
#include "Search.h"int main()
{int a[10] = {1,16,24,35,47,59,62,73,88,99};int key = 62;printf("position: %d \n",BiSearch(a,10,key));printf("position: %d \n",IVSearch(a,10,key));
}
110
1 
//************************Search.h***********************************

2 
#ifndef SEARCH_H

3 
#define SEARCH_H

4
5 
#include <stdio.h>

6 
#include <stdlib.h>

7
8 
int BiSearch(int array[],int n,int key);

9
10 
int IVSearch(int array[],int n,int key);

11
12 
int FibSearch(int array[],int n,int key);

13
14
15
16 
#endif //SEARCH_H

17
18
19 
//************************Search.c*************************************

20 
#include "Search.h"

21
22
23 
//折半查找

24 
int BiSearch(int array[],int n,int key)

25 
{

26 
    if(NULL == array)return -1;

27 
    int left = 0;

28 
    int right= n-1;

29 
    int mid  = (left+right)/2;

30
31 
    while(left <= right)

32 
    {

33 
        if(array[mid] == key)

34 
        {

35 
            return mid;

36 
        }

37 
        else if(array[mid] > key)

38 
        {

39 
            right = mid-1;

40 
        }

41 
        else if(array[mid] < key)

42 
        {

43 
            left = mid+1;

44 
        }

45 
        mid = (left+right)/2;

46 
    }

47 
    return -1;

48 
}

49
50
51 
//插值查找

52 
int IVSearch(int array[],int n,int key)

53 
{

54 
    if(NULL == array)return -1;

55 
    int left = 0;

56 
    int right= n-1;

57 
    int mid  = left+(right-left)*(key-array[left])/(array[right]-array[left]);

58
59 
    while(left <= right)

60 
    {

61 
        if(array[mid] == key)

62 
        {

63 
            return mid;

64 
        }

65 
        else if(array[mid] > key)

66 
        {

67 
            right = mid-1;

68 
        }

69 
        else if(array[mid] < key)

70 
        {

71 
            left = mid+1;

72 
        }

73 
        mid  = left+(right-left)*(key-array[left])/(array[right]-array[left]);

74 
    }

75 
    return -1;

76 
}

77
78
79
80 
int FibSearch(int array[],int n,int key)

81 
{

82 
    int F[] = {1,1,2,3,5,8,13,21,34,55,89};

83

84
85 
    int left = 0;

86 
    int right= n-1;

87 
    int mid;

88
89 
    int k = 0;

90 
    while(n>F[k]-1)

91 
    {

92 
        k++;

93 
    }

94 
    for(int i=n;i < F[k])

95
96 
}

97
98
99 
//************************SearchTest.c*************************************

100 
#include "Search.h"

101
102
103 
int main()

104 
{

105 
    int a[10] = {1,16,24,35,47,59,62,73,88,99};

106 
    int key = 62;

107
108 
    printf("position: %d \n",BiSearch(a,10,key));

109 
    printf("position: %d \n",IVSearch(a,10,key));

110 
}

2.斐波那契查找 
#include <stdio.h>
#include <stdlib.h>
#define MAXN 20  /* *产生斐波那契数列 * */
void Fibonacci(int *f)
{  int i;  f[0] = 1;  f[1] = 1;  for(i = 2;i < MAXN; ++i)  f[i] = f[i - 2] + f[i - 1];
}  /* * 查找 * */
int Fibonacci_Search(int *a, int key, int n)
{  int i, low = 0, high = n - 1;  int mid = 0;  int k = 0;  int F[MAXN];  Fibonacci(F);  while(n > F[k] - 1)          //计算出n在斐波那契中的数列  ++k;  for(i = n;i < F[k] - 1;++i) //把数组补全  a[i] = a[high];  while(low <= high)  {  mid = low + F[k-1] - 1;  //根据斐波那契数列进行黄金分割  if(a[mid] > key)  {  high = mid - 1;  k = k - 1;  }  else if(a[mid] < key)  {  low = mid + 1;  k = k - 2;  }  else  {  if(mid <= high) //如果为真则找到相应的位置  return mid;  else  return -1;  }  }  return 0;
}  int main()
{     int a[MAXN] = {5,15,19,20,25,31,38,41,45,49,52,55,57};  int k, res = 0;  printf("请输入要查找的数字:\n");  scanf("%d", &k);  res = Fibonacci_Search(a,k,13);  if(res != -1)  printf("在数组的第%d个位置找到元素:%d\n", res + 1, k);  else  printf("未在数组中找到元素:%d\n",k);  return 0;
}
68
1 
#include <stdio.h>

2 
#include <stdlib.h>

3 
#define MAXN 20

4

5 
/*

6 
 *产生斐波那契数列

7 
 * */

8 
void Fibonacci(int *f)

9 
{

10 
    int i;

11 
    f[0] = 1;

12 
    f[1] = 1;

13 
    for(i = 2;i < MAXN; ++i)

14 
        f[i] = f[i - 2] + f[i - 1];

15 
}

16

17 
/*

18 
 * 查找

19 
 * */

20 
int Fibonacci_Search(int *a, int key, int n)

21 
{

22 
    int i, low = 0, high = n - 1;

23 
    int mid = 0;

24 
    int k = 0;

25 
    int F[MAXN];

26 
    Fibonacci(F);

27 
    while(n > F[k] - 1)          //计算出n在斐波那契中的数列

28 
        ++k;

29 
    for(i = n;i < F[k] - 1;++i) //把数组补全

30 
        a[i] = a[high];

31 
    while(low <= high)

32 
    {

33 
        mid = low + F[k-1] - 1;  //根据斐波那契数列进行黄金分割

34 
        if(a[mid] > key)

35 
        {

36 
            high = mid - 1;

37 
            k = k - 1;

38 
        }

39 
        else if(a[mid] < key)

40 
        {

41 
            low = mid + 1;

42 
            k = k - 2;

43 
        }

44 
        else

45 
        {

46 
            if(mid <= high) //如果为真则找到相应的位置

47 
                return mid;

48 
            else

49 
                return -1;

50 
        }

51 
    }

52 
    return 0;

53 
}

54

55 
int main()

56 
{

57 
    int a[MAXN] = {5,15,19,20,25,31,38,41,45,49,52,55,57};

58 
    int k, res = 0;

59 
    printf("请输入要查找的数字:\n");

60 
    scanf("%d", &k);

61 
    res = Fibonacci_Search(a,k,13);

62 
    if(res != -1)

63 
        printf("在数组的第%d个位置找到元素:%d\n", res + 1, k);

64 
    else

65 
        printf("未在数组中找到元素:%d\n",k);

66 
    return 0;

67 
}

68

3.二叉排序树 
//****************************BiSortTree.h*************************
#ifndef BISORTTREE_H
#define BISORTTREE_H#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>typedef int datatype;typedef struct BiSNode
{datatype data;struct BiSNode *left,*right;
}BiSNode,*BiSTree;//在二叉排序树中查找key
bool SearchBST(BiSTree T,datatype key,BiSTree f,BiSTree *p);//按顺插入
bool InsertBST(BiSTree *T,datatype key);//删除节点
bool DeleteBST(BiSTree *T,datatype key);bool Delete(BiSTree *p);#endif  //BISORTTREE_H//****************************BiSortTree.c*************************
#include "BiSortTree.h"//在二叉排序树中查找key
bool SearchBST(BiSTree T,datatype key,BiSTree f,BiSTree *p)
{if(!T){*p = f;return false;}else if(key == T->data){*p = T;return true;}else if(key < T->data){return SearchBST(T->left,key,T,p);}else{return SearchBST(T->right,key,T,p);}
}//按顺插入
bool InsertBST(BiSTree *T,datatype key)
{BiSTree p,s;if(!SearchBST(*T,key,NULL,&p)){s = (BiSTree)malloc(sizeof(BiSNode));s->data = key;s->left = s->right = NULL;if(!p){*T = s;}else if(key < p->data){p->left = s;}else {p->right = s;}return true;}else{return false;}
}//删除节点
bool DeleteBST(BiSTree *T,datatype key)
{if(!*T){return false;}else{if(key == (*T)->data){return Delete(T);}else if(key < (*T)->data){DeleteBST(&(*T)->left,key);}else{DeleteBST(&(*T)->right,key);}}
}bool Delete(BiSTree *p)
{BiSTree q,s;if(NULL == (*p)->left){q = *p;*p = (*p)->right;free(q);}else if(NULL == (*p)->right){q = *p;*p = (*p)->left;free(q);}else{q = *p;s = (*p)->left;while(s->right){q = s;s = s->right;}(*p)->data = s->data;if(q != *p){q->right = s->left;}else{q->left  = s->left;}free(s);}return true;
}//****************************BiSortTreeTest.c*************************
#include "BiSortTree.h"int main()
{int i;int a[10] ={62,88,58,47,35,73,51,99,37,93};BiSTree T = NULL;for(i = 0;i < 10;i++){InsertBST(&T,a[i]);}BiSTree p,f;printf("%d \n",p->data);SearchBST(T,58,f,&p);printf("%d \n",p->data);DeleteBST(&T,58);printf("%d \n",p->data);
}
x
1 
//****************************BiSortTree.h*************************

2 
#ifndef BISORTTREE_H

3 
#define BISORTTREE_H

4
5
6 
#include <stdio.h>

7 
#include <stdlib.h>

8 
#include <stdbool.h>

9
10 
typedef int datatype;

11
12 
typedef struct BiSNode

13 
{

14 
    datatype data;

15 
    struct BiSNode *left,*right;

16 
}BiSNode,*BiSTree;

17
18
19 
//在二叉排序树中查找key

20 
bool SearchBST(BiSTree T,datatype key,BiSTree f,BiSTree *p);

21
22 
//按顺插入

23 
bool InsertBST(BiSTree *T,datatype key);

24
25 
//删除节点

26 
bool DeleteBST(BiSTree *T,datatype key);

27
28
29 
bool Delete(BiSTree *p);

30
31
32 
#endif  //BISORTTREE_H

33
34
35 
//****************************BiSortTree.c*************************

36 
#include "BiSortTree.h"

37
38 
//在二叉排序树中查找key

39 
bool SearchBST(BiSTree T,datatype key,BiSTree f,BiSTree *p)

40 
{

41 
    if(!T)

42 
    {

43 
        *p = f;

44 
        return false;

45 
    }

46 
    else if(key == T->data)

47 
    {

48 
        *p = T;

49 
        return true;

50 
    }

51 
    else if(key < T->data)

52 
    {

53 
        return SearchBST(T->left,key,T,p);

54 
    }

55 
    else

56 
    {

57 
        return SearchBST(T->right,key,T,p);

58 
    }

59 
}

60
61 
//按顺插入

62 
bool InsertBST(BiSTree *T,datatype key)

63 
{

64 
    BiSTree p,s;

65 
    if(!SearchBST(*T,key,NULL,&p))

66 
    {

67 
        s = (BiSTree)malloc(sizeof(BiSNode));

68 
        s->data = key;

69 
        s->left = s->right = NULL;

70
71 
        if(!p)

72 
        {

73 
            *T = s;

74 
        }

75 
        else if(key < p->data)

76 
        {

77 
            p->left = s;

78 
        }

79 
        else

80 
        {

81 
            p->right = s;

82 
        }

83 
        return true;

84 
    }

85 
    else

86 
    {

87 
        return false;

88 
    }

89 
}

90
91 
//删除节点

92 
bool DeleteBST(BiSTree *T,datatype key)

93 
{

94 
    if(!*T)

95 
    {

96 
        return false;

97 
    }

98 
    else

99 
    {

100 
        if(key == (*T)->data)

101 
        {

102 
            return Delete(T);

103 
        }

104 
        else if(key < (*T)->data)

105 
        {

106 
            DeleteBST(&(*T)->left,key);

107 
        }

108 
        else

109 
        {

110 
            DeleteBST(&(*T)->right,key);

111 
        }

112 
    }

113 
}

114
115 
bool Delete(BiSTree *p)

116 
{

117 
    BiSTree q,s;

118
119 
    if(NULL == (*p)->left)

120 
    {

121 
        q = *p;

122 
        *p = (*p)->right;

123 
        free(q);

124 
    }

125 
    else if(NULL == (*p)->right)

126 
    {

127 
        q = *p;

128 
        *p = (*p)->left;

129 
        free(q);

130 
    }

131 
    else

132 
    {

133 
        q = *p;

134 
        s = (*p)->left;

135
136 
        while(s->right)

137 
        {

138 
            q = s;

139 
            s = s->right;

140 
        }

141 
        (*p)->data = s->data;

142
143 
        if(q != *p)

144 
        {

145 
            q->right = s->left;

146 
        }

147 
        else

148 
        {

149 
            q->left  = s->left;

150 
        }

151 
        free(s);

152 
    }

153 
    return true;

154 
}

155
156 
//****************************BiSortTreeTest.c*************************

157 
#include "BiSortTree.h"

158
159
160
161 
int main()

162 
{

163 
    int i;

164 
    int a[10] ={62,88,58,47,35,73,51,99,37,93};

165 
    BiSTree T = NULL;

166 
    for(i = 0;i < 10;i++)

167 
    {

168 
        InsertBST(&T,a[i]);

169 
    }

170

171 
    BiSTree p,f;

172 
    printf("%d \n",p->data);

173 
    SearchBST(T,58,f,&p);

174 
    printf("%d \n",p->data);

175
176 
    DeleteBST(&T,58);

177
178 
    printf("%d \n",p->data);

179 
}

4.AVL（平衡二叉树） 
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#define EH 0            /*等高*/
#define LH 1            /*左高*/
#define RH -1            /*右高*/typedef int ElemType;                 /*数据类型*/typedef struct BiTree{ElemType data;                    /*数据元素*/int BF;                         /*平衡因子*/struct BiTree *lchild,*rchild;     /*左右子女指针*/
}*Bitree,BitreeNode;int InsertAVL(Bitree *T,ElemType e,bool *taller);
void LeftBalance(Bitree *T);
void RightBalance(Bitree *T);
void R_Rotate(Bitree *T);
void L_Rotate(Bitree *T);
bool *taller;
//bool *taller= (bool *)malloc(sizeof(bool));int main(void)
{taller= (bool *)malloc(sizeof(bool));int data;Bitree T=NULL;while(1){printf("enter the number(zero to exit):");scanf("%d",&data);if(0==data)break;InsertAVL(&T,data,taller);}return 0;
}/*若在平衡的二叉排序树T 中不存在和e 有相同关键码的结点，则插入一个数据元素为e 的*/
/*新结点，并反回1，否则反回0。若因插入而使二叉排序树失去平衡，则作平衡旋转处理，*/
/*布尔型变量taller 反映T 长高与否*/
int InsertAVL(Bitree *T,ElemType e,bool *taller)
{if(!*T)                /*插入新结点，树“长高”，置taller 为TURE*/{(*T)=(Bitree)malloc(sizeof(BitreeNode));(*T)->data = e;(*T)->lchild = (*T)->rchild = NULL;(*T)->BF = EH;*taller = true;}else{if(e==(*T)->data)        /*树中存在和e 有相同关键码的结点，不插入*/{*taller = false;return 0;}    if(e<(*T)->data){if(!InsertAVL(&(*T)->lchild,e,taller))    return 0;  /*未插入*/if(*taller)switch((*T)->BF){    case EH :                    /*原本左、右子树等高，因左子树增高使树增高*/(*T)->BF=LH;*taller=true;break;case LH :                    /*原本左子树高，需作左平衡处理*/LeftBalance(T);*taller=false;break;case RH :                    /*原本右子树高，使左、右子树等高*/(*T)->BF=EH; *taller=false;break;}}else{if(!InsertAVL(&(*T)->rchild,e,taller))    return 0;  /*未插入*/if(*taller)switch((*T)->BF){    case EH :                    /*原本左、右子树等高，因右子树增高使树增高*/(*T)->BF=RH;*taller=true;break;case LH :                    /*原本左子树高，使左、右子树等高*/(*T)->BF=EH; *taller=false;break;case RH :                    /*原本右子树高，需作右平衡处理*/RightBalance(T);*taller=false;break;}}}return 1;
}/*对以*p 指向的结点为根的子树，作左平衡旋转处理，处理之后，*p 指向的结点为子树的新根*/
void LeftBalance(Bitree *T)
{Bitree L=(*T)->lchild,Lr;             /*L 指向*T左子树根结点*/switch(L->BF)                /*检查L 平衡度，并作相应处理*/{case LH:                    /*新结点插在*p 左子树的左子树上，需作单右旋转处理*/(*T)->BF=L->BF=EH;R_Rotate(T);break;case EH:             /*原本左、右子树等高，因左子树增高使树增高*/(*T)->BF=LH;    //这里的EH好像没有写的必要 *taller=true;break;case RH:                     /*新结点插在*T 左孩子的右子树上，需作先左后右双旋处理*/Lr=L->rchild;             /*Lr 指向*p 左孩子的右子树根结点*/    switch(Lr->BF)         /*修正*T 及其左子树的平衡因子*/{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(&L);        /*对*T 的左子树作左旋转处理*/R_Rotate(T);        /*对*T 作右旋转处理*/}
}
//这里和leftbalance一个道理，试着自己写一下
void RightBalance(Bitree *T)
{Bitree Lr= (*T)->rchild,L;switch(Lr->BF){case EH:*taller = true;(*T)->BF = RH;break;case RH:(*T)->BF=Lr->BF=EH;L_Rotate(T);break;case LH:L = Lr->lchild;switch(L->BF){case EH:(*T)->BF=Lr->BF= EH;break;case RH:Lr->BF= EH;(*T)->BF = LH;break;case LH:(*T)->BF = LH;Lr->BF = EH;break;}L->BF = EH;R_Rotate(&Lr);        L_Rotate(T);    }
}/*对以*T 指向的结点为根的子树，作右单旋转处理，处理之后，*T 指向的结点为子树的新根*/
void R_Rotate(Bitree *T)
{ Bitree L=(*T)->lchild;                 /*L 指向*T 左子树根结点*/(*T)->lchild=L->rchild;                 /*L 的右子树挂接*T 的左子树*/L->rchild=*T; *T=L;             /* *L 指向新的根结点*/
}/*对以*p 指向的结点为根的子树，作左单旋转处理，处理之后，*p 指向的结点为子树的新根*/
void L_Rotate(Bitree *T)
{ Bitree Lr=(*T)->rchild;                 /*Lr 指向*T 右子树根结点*/(*T)->rchild=Lr->lchild;                 /*L 的左子树挂接*p 的右子树*/Lr->lchild=*T; *T=Lr;                                     /* *L 指向新的根结点*/
}
1
209

1 
#include<stdio.h>

2 
#include<stdlib.h>

3 
#include<stdbool.h>

4 
#define EH 0            /*等高*/

5 
#define LH 1            /*左高*/

6 
#define RH -1            /*右高*/

7

8 
typedef int ElemType;                 /*数据类型*/

9
10 
typedef struct BiTree{

11 
    ElemType data;                    /*数据元素*/

12 
    int BF;                         /*平衡因子*/

13 
    struct BiTree *lchild,*rchild;     /*左右子女指针*/

14 
}*Bitree,BitreeNode;

15
16
17 
int InsertAVL(Bitree *T,ElemType e,bool *taller);

18 
void LeftBalance(Bitree *T);

19 
void RightBalance(Bitree *T);

20 
void R_Rotate(Bitree *T);

21 
void L_Rotate(Bitree *T);

22 
bool *taller;

23 
//bool *taller= (bool *)malloc(sizeof(bool));

24
25 
int main(void)

26 
{

27 
    taller= (bool *)malloc(sizeof(bool));

28 
    int data;

29 
    Bitree T=NULL;

30 
    while(1)

31 
    {

32 
        printf("enter the number(zero to exit):");

33 
        scanf("%d",&data);

34 
        if(0==data)break;

35 
        InsertAVL(&T,data,taller);

36

37 
    }

38

39

40

41 
    return 0;

42 
}

43
44
45 
/*若在平衡的二叉排序树T 中不存在和e 有相同关键码的结点，则插入一个数据元素为e 的*/

46 
/*新结点，并反回1，否则反回0。若因插入而使二叉排序树失去平衡，则作平衡旋转处理，*/

47 
/*布尔型变量taller 反映T 长高与否*/

48 
int InsertAVL(Bitree *T,ElemType e,bool *taller)

49 
{

50 
    if(!*T)                /*插入新结点，树“长高”，置taller 为TURE*/

51 
    {

52 
        (*T)=(Bitree)malloc(sizeof(BitreeNode));

53 
        (*T)->data = e;

54 
        (*T)->lchild = (*T)->rchild = NULL;

55 
        (*T)->BF = EH;

56 
        *taller = true;

57 
    }

58 
    else

59 
    {

60 
        if(e==(*T)->data)        /*树中存在和e 有相同关键码的结点，不插入*/

61 
        {

62 
            *taller = false;

63 
            return 0;

64 
        }

65 
        if(e<(*T)->data)

66 
        {

67 
            if(!InsertAVL(&(*T)->lchild,e,taller))    return 0;  /*未插入*/

68 
            if(*taller)

69 
            switch((*T)->BF)

70 
            {

71 
                case EH :                    /*原本左、右子树等高，因左子树增高使树增高*/

72 
                    (*T)->BF=LH;

73 
                    *taller=true;

74 
                    break;

75

76 
                case LH :                    /*原本左子树高，需作左平衡处理*/

77 
                    LeftBalance(T);

78 
                    *taller=false;

79 
                    break;

80

81 
                case RH :                    /*原本右子树高，使左、右子树等高*/

82 
                    (*T)->BF=EH;

83 
                    *taller=false;

84 
                    break;

85

86 
            }

87

88 
        }

89 
        else

90 
        {

91 
            if(!InsertAVL(&(*T)->rchild,e,taller))    return 0;  /*未插入*/

92 
            if(*taller)

93 
            switch((*T)->BF)

94 
            {

95 
                case EH :                    /*原本左、右子树等高，因右子树增高使树增高*/

96 
                    (*T)->BF=RH;

97 
                    *taller=true;

98 
                    break;

99

100 
                case LH :                    /*原本左子树高，使左、右子树等高*/

101 
                    (*T)->BF=EH;

102 
                     *taller=false;

103 
                     break;

104

105 
                case RH :                    /*原本右子树高，需作右平衡处理*/

106 
                    RightBalance(T);

107 
                    *taller=false;

108 
                     break;

109

110 
            }

111 
        }

112 
    }

113 
    return 1;

114 
}

115
116
117
118 
/*对以*p 指向的结点为根的子树，作左平衡旋转处理，处理之后，*p 指向的结点为子树的新根*/

119 
void LeftBalance(Bitree *T)

120 
{

121 
    Bitree L=(*T)->lchild,Lr;             /*L 指向*T左子树根结点*/

122 
    switch(L->BF)                /*检查L 平衡度，并作相应处理*/

123 
    {

124 
        case LH:                    /*新结点插在*p 左子树的左子树上，需作单右旋转处理*/

125 
            (*T)->BF=L->BF=EH;

126 
             R_Rotate(T);

127 
             break;

128 
        case EH:             /*原本左、右子树等高，因左子树增高使树增高*/

129 
            (*T)->BF=LH;    //这里的EH好像没有写的必要

130 
              *taller=true;

131 
              break;

132 
        case RH:                     /*新结点插在*T 左孩子的右子树上，需作先左后右双旋处理*/

133 
            Lr=L->rchild;             /*Lr 指向*p 左孩子的右子树根结点*/

134 
            switch(Lr->BF)         /*修正*T 及其左子树的平衡因子*/

135 
            {

136 
                case LH:

137 
                    (*T)->BF = RH;

138 
                    L->BF = EH;

139 
                    break;

140 
                case EH:

141 
                    (*T)->BF = L->BF= EH;

142 
                    break;

143 
                case RH:

144 
                    (*T)->BF = EH;

145 
                    L->BF = LH;

146 
                    break;

147

148 
            }

149 
            Lr->BF = EH;

150 
            L_Rotate(&L);        /*对*T 的左子树作左旋转处理*/

151 
            R_Rotate(T);        /*对*T 作右旋转处理*/

152 
    }

153 
}

154 
//这里和leftbalance一个道理，试着自己写一下

155 
void RightBalance(Bitree *T)

156 
{

157 
    Bitree Lr= (*T)->rchild,L;

158 
    switch(Lr->BF)

159 
    {

160 
        case EH:

161 
            *taller = true;

162 
            (*T)->BF = RH;

163 
            break;

164 
        case RH:

165 
            (*T)->BF=Lr->BF=EH;

166 
            L_Rotate(T);

167 
            break;

168 
        case LH:

169 
            L = Lr->lchild;

170 
            switch(L->BF)

171 
            {

172 
                case EH:

173 
                    (*T)->BF=Lr->BF= EH;

174 
                    break;

175 
                case RH:

176 
                    Lr->BF= EH;

177 
                    (*T)->BF = LH;

178 
                    break;

179 
                case LH:

180 
                    (*T)->BF = LH;

181 
                    Lr->BF = EH;

182 
                    break;

183

184 
            }

185 
            L->BF = EH;

186 
            R_Rotate(&Lr);

187 
            L_Rotate(T);

188

189 
    }

190 
}

191
192
193 
/*对以*T 指向的结点为根的子树，作右单旋转处理，处理之后，*T 指向的结点为子树的新根*/

194 
void R_Rotate(Bitree *T)

195 
{

196 
    Bitree L=(*T)->lchild;                 /*L 指向*T 左子树根结点*/

197 
    (*T)->lchild=L->rchild;                 /*L 的右子树挂接*T 的左子树*/

198 
    L->rchild=*T; *T=L;             /* *L 指向新的根结点*/

199 
}

200
201
202 
/*对以*p 指向的结点为根的子树，作左单旋转处理，处理之后，*p 指向的结点为子树的新根*/

203 
void L_Rotate(Bitree *T)

204 
{

205 
    Bitree Lr=(*T)->rchild;                 /*Lr 指向*T 右子树根结点*/

206 
    (*T)->rchild=Lr->lchild;                 /*L 的左子树挂接*p 的右子树*/

207 
    Lr->lchild=*T;

208 
    *T=Lr;                                     /* *L 指向新的根结点*/

209 
}

附件列表

  • 查找.jpg

转载于:https://www.cnblogs.com/LyndonMario/p/9326364.html

Chapter 8(查找)相关推荐

  1. 算法（第4版） Chapter 5.2 单词查找树

    Algorithms Fourth Edition Written By Robert Sedgewick & Kevin Wayne Translated By 谢路云 Chapter 5 ...

  2. Chapter 1 Securing Your Server and Network(9):使用Kerberos用于身份验证

    原文: Chapter 1 Securing Your Server and Network(9):使用Kerberos用于身份验证 原文出处:http://blog.csdn.net/dba_hua ...

  3. halcon的算子清点：Chapter 9 匹配

    Chapter 9 :Matching 9.1 Component-Based 1. clear_all_component_models   功能:释放所有组件模型的内存. 2. clear_all ...

  4. halcon的算子清点：Chapter 7 :Image

    Chapter 7 :Image 7.1 Access 1. get_grayval   功能:获取一个图像目标的灰度值. 2. get_image_pointer1  功能:获取一个通道的指针. 3 ...

  5. SSM Chapter 12 SpringMVC扩展和SSM框架整合

    SSM Chapter 12 SpringMVC扩展和SSM框架整合 笔记 本章目标: 掌握JSON对象的处理 理解数据转换和格式化 了解本地化 掌握Spring MVC+Spring+MyBatis ...

  6. 《Presto（Trino）——The Definitive Guide》CHAPTER 6 Connectors Advanced CHAPTER 7 Connector Examples

    Presto(暂译:普雷斯托)系列文章目录-CHAPTER 6 Connectors This book provides a great introduction to Presto and tea ...

  7. java依赖什么意思,JavaEE中的依赖性——依赖查找

    关于依赖性管理我们要介绍的第一个策略就是依赖查找(dependency lookup).这种策略是JavaEE中传统形式的依赖性管理,这里可以看到JavaEE规范中的JNDI(Java Naming ...

  8. 【翻译】Xv6 book Chapter 8:File system

    Chapter 8 File system 文件系统的目的是阻止和存储数据.文件系统持久地支持在用户和应用之间分享数据,所以这些数据在重启之后仍然是可以得到的. xv6的文件系统提供了类Unix的文件 ...

  9. 《编程之美》 查找最大（小）的k个元素

    http://blog.csdn.net/v_july_v/article/details/6370650 http://blog.csdn.net/insistgogo/article/detail ...

最新文章

  1. mysql数据库空闲时间设定_关于数据库连接池的最大空闲时间的配置
  2. Redis实战之征服 Redis + Jedis + Spring （三）
  3. 【分组背包问题 (HDU 3535 )】
  4. Gitee X Serverless Devs 邀你来“领赏”啦！
  5. Object Tracking using OpenCV (C++/Python)（使用OpenCV进行目标跟踪）
  6. linux下ts转mp4,ffmpeg安装及实现视频格式的转换、分片（ts m3u8）
  7. c语言代码中调用系统命令行.sh shell脚本，linux shell system传参
  8. 第 2 章 类加载子系统
  9. mysql select大全_Mysql select 大全
  10. 向小伙伴讲讲搜索引擎？读完这个文章先
  11. 计算机课集体备课,《计算机应用基础》集体备课方案
  12. 早悟兰因（兰因絮果）
  13. hprose-php教程,PHP RPC框架 hprose 上手玩玩
  14. 微机 —— 8086微处理器的内部结构
  15. 【微信小程序】深入学习小程序基本目录文件与代码结构
  16. 计算机网络常见面试题目
  17. Linux运维笔记-日常操作命令总结（1）
  18. 中国资源卫星应用中心_数据下载
  19. css 设置背景图一半_css怎么背景图片显示不全？
  20. 小学语文计算机的运用计划,语文计算机应用教学计划

热门文章

  1. Spring+Hibernate项目在weblogic中部署的一些问题
  2. C++基本要点复习--------coursera程序设计实习（PKU）的lecture notes
  3. LinkedBlockingQueue应用实例
  4. 《资安人》：迈向成功SOC之路
  5. 机器学习中的模型评价、模型选择及算法选择
  6. react hooks使用_为什么要使用React Hooks？
  7. 谢尔盖.布林的早期思想_谷歌联合创始人谢尔盖·布林（Sergey Brin）谈人工智能与自动化...
  8. colsure php_PHP Closure(闭包)类详解
  9. c# html文本编辑器,C#实现简单文本编辑器
  10. 1039 到底买不买