查找排序的相关算法

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;
				else
						low = 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);
				else
						return 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)//当树为空或者前一个树比后一个树大则返回0
						return 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;
				else
						balance = 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;
				else
					high = 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;
		}
}