1、折半查找非递归算法

int Binary_Search(SqList L,ElemType key)
{int low = 0,high = L.length - 1,mid;while(low <= high){mid = (low+high)/2;if(L.elem[mid] == key)return mid;else if(L.elem[mid] > key)high = mid-1;elselow = low+1;}return -1
}

2、折半查找递归算法

int BinSearch_Cur(SqList L,keyType key,int low,int high)
{if(low > high)return 0;if(low <= high){mid = (low+high)/2;if(L.elem[mid] == key)return mid;else if(key < L.elem[mid])return BinSearch_Cur(L,key,low,mid-1);elsereturn BinSearch_Cur(L,key,mid+1,high);}
}

3、判断是否为二叉排序树（判断结点之前的关系）
算法思想
根据二叉排序树的定义，对二叉排序树进行递归的遍历，左子小，右子大，一旦不满足则不是

void JudgeBST(BiTree ,int &flags)
{if(T != NULL && flag){judgeBST(T->lchild,flag);//中序遍历左子树if(pre == NULL)//中序的第一个结点不必判断pre = T;else if(pre->data < T->data)//如果前驱的结点值小于根结点，则是否则不是pre = T;else flag = 0;JudgeBST(T->rchild,flag);//中序遍历右子树}
}

4、判断二叉排序树（中序遍历判断次序）
算法思想
二叉排序树的中序序列为递增，对于二叉树的中序遍历，如果始终能保持前一个值比后一个值小，则为二叉排序树

int judgeBST(BSTNode *bt)
{int b1,b2;if(bt == NULL)return 1;else{b1 = judgeBST(bt->lchild);if(b1 == 0 ||pre > bt->data)//当树为空或者前一个树比后一个树大则返回0return 0;pre = bt->data;//保存当前结点b2 = judgeBST(bt->rchild);return b2;}
}

5、判断二叉树是否为平衡二叉树
算法思想

void judgeAVL(BSTNode *bt,int &balance,int &h)//(每看懂)
{int bl,br,hl,hr;if(bt == NULL){h = 0;balance = 1;}else if(bt->lchild == NULL && bt->rchild == NULL){h = 1;balance = 1;}else{judgeAVL(bt->lchild,balance,h1);judgeAVL(bt->rchild,balance,hr);h = (h1>h2:hl:hr) + 1;if(abs(h1-h2) < 2)balance = bl&br;elsebalance = 0;}
}

6、计算AVL中所有结点的平衡因子

int Computebf(BSTNode *&b)
{int max1,max2;if(b == NULL)return 0;if(b->lchild == NULL && b->rchild == NULL)//如果是叶子结点bf为0,高度返回1{b->bf = 0;return 1;}else//否则分别计算左右子树的高度{max1 = Computebf(b->lchild);max2 = Computebf(b->rchild);b->bf = max1-max2;//bf为左右子树的高度差return (max1>max2:max1+1:max2+1);}
}

7、快速排序
算法思想
从左往右找小于中枢的结点，从右往左找大于中枢的结点
当low和high碰到头的时候把低的数据给高的位置，因为要进行排序

int partition(SqList &L,int low,int high)
{L,r[0] = L,r[low];pivotkey = L.r[low].key;while(low < high){while(low < high && L.r[high].key >= pivotkey)--high;//从左往右找小于中枢的结点while(log < high && L.r[low].key <= pivotkey)++low;//从右往左找大于中枢的结点L.r[high] = L.r[low];//把比中枢大的移动到高端，（为沙移动这个）}L.r[low] = L.r[0];return low;//返回中枢位置(为沙返回这个值)
}
void QSort(SqList &L,int low,int high)
{if(low < high){priotloc = partition(L,low,high);QSort(L.low,priotloc-1);QSort(L,pivotloc+1,high);}
}

8、编写算法负值在前，非负在后
算法思想
从左往右找负，从右往左找正

void process(int a[],int n)
{int low = 0,high = n-1;while(low < high){while(low < high && L.r[high].key > 0)//并且当前的结点大于0则继续，否则停止high--;while(low < high && L.r[low.key] < 0)//并且当前的结点小于0则继续，否则停止low++;if(low < high){	temp = L.r[high].key; L.r[high].key = L.r[low].key;L.r[low].key = temp;low++;high--;				}}
}

9、编写算法要求左小于k，右边大于k
算法思想
从左往右找小于k，从右往左找大于k

void process(int a[],int n,int k)
{int low = 0,high = n-1;while(low < high){while(low < high && a[high] > k)//从左往右找小于k，如果low<high，并且当前的结点大于k则继续，否则停止high--;while(low < high && a[low] < k)//从右往左找大于k，如果low<high，并且当前的结点小于k则继续，否则停止low++;if(low < high){temp = a[low];a[low] = a[high];a[high] = temp;high--;low++;}}
}

10、元素递增有序编写算法完成以下要求
（1）查找值为x的元素
（2）查找到后与后继元素交换位置
（3）若查找不到则插入到表中仍然保持有序
算法思想
采用快排的思想查找值x，如果找到则输出，并且交换x的和后继的位置，

void SearchExchangeInsert(ElemType a[],ElemType x)
{int low = 0,high = n-1;while(low <= high){mid = (low + high)/2;//折半查找if(a[mid] == x)break;//找到了else if(a[mid] < x)low = mid+1;elsehigh = mid-1;}if(a[mid] == x&& mid != n)//找到后交换{int temp = a[mid];a[mid] = a[mid+1];a[mid+1] = temp;}if(low > high)//当low>high时说明没有找到{for(i = n-1;i > high;i--)//将元素后移，high的位置为最后结点的位置{a[i+1] = a[i];}a[i+1] = x;}
}