搜索排序

#include <iostream>
using namespace std ;

//排序--------------------------------------------------------------------------------
//交换排序：冒泡，快排
//冒泡p=right-1-()
template<typename T>
void maopao(T *p, int left, int right) {
	for (int i = 1; i <= right - left; ++i) {
		for (int j = left; j <= right - i; j++) {
			if (*(p + j) < * (p + j + 1)) {
				int tmp = *(p + j); *(p + j) = *(p + j + 1); *(p + j + 1) = tmp;
			}
		}
	}
}
//快排
template <typename T>
void kuaipai(T *p , int left , int right) {
	if (left >= right)
		return ;
	int i = left; int j = right ; T key = p[left] ;
	while (i != j)
	{
		while (p[j] >= key  && i < j)  j--;
		p[i] = p[j] ;
		while (p[i] <= key && i < j) i++;
		p[j] = p[i] ;
	}
	p[i] = key;
	kuaipai(p, left, i - 1);
	kuaipai(p, i + 1, right);
}
//插入排序
//
template <typename T>
void charu(T *p , int left , int right) {
	for (int i = left + 1; i < right; i++) {
		//循环次数
		//p[i]  charu p[left]-p[i-1]
		T key = p[i];
		int tmp;
		for (tmp = i - 1; key < p[tmp] && tmp >= left; tmp--) { //后一个条件防止越界
			p[tmp + 1] = p[tmp];
		}
		p[tmp + 1] = key;
	}
}

//简单选择排序
template <typename T>
void jiandan(T *p , int left, int right) {
	for (int i = left; i < right; i++) { //循环次数
		//find min
		int min = i;
		for (int j = i; j <= right; j++) {
			if (p[min] > p[j]) {
				min = j;
			}
		}
		if (min != i) {
			int tmp = p[min] ; p[min] = p[i]; p[i] = tmp;

		}


	}
}
//归并
template <typename T>
void guibing(T *p, int left , int right) {
	if (left == right)
		return ;
	if (left + 1 == right) {
		if (p[left] > p[right]) {
			T tmp = p[left]; p[left] = p[right]; p[right] = tmp; return;
		}
	}
	guibing(p, left, (left + right) / 2);
	guibing(p, (left + right) / 2 + 1, right);
	for (int i = (left + right) / 2 + 1; i <= right; i++) {
		T key = p[i] ;
		int tmp;
		for (tmp = i - 1; key < p[tmp] && tmp >= left; tmp--)
			p[tmp + 1] = p[tmp];
		p[tmp + 1] = key;
	}


}
//堆排
int length = 16;
void duipai(int *p , int i);
void build(int *p) {
	for (int i = length / 2 ; i >= 0; i--) {
		duipai(p, i);
	}
}

void duipai(int *p , int i) {
	//建堆
	int left = 2 * i + 1 , right = 2 * i + 2, largest = i ;
	if (length > left && p[left]>p[largest])  largest =  left;
	if (length > right&& p[right]>p[largest]) largest = right;
	if (largest != i)   {int tmp = p[largest]; p[largest] = p[i]; p[i] = tmp; duipai(p, largest);}

}

void heapsort(int *p) {
	int len = length;
	for (int i = 0; i < len; i++) {
		int tmp = p[0] ; p[0] = p[len - i - 1]; p[len- i - 1] = tmp;
		length--;
		duipai(p, 0);
	}
}

//查找--------------------------------------------------------------------------------
//二分查找
template <typename T>
T* binary_search(T* a, int n, const T& x)
{
    int first = 0;
    int last = n-1;
    while (last >= first )
    {
        int mid = (last + first) / 2;//注意 越界 问题 int mid = first + (last - first)/2;
        if (a[mid] == x)
            return a + mid;
        else if (a[mid] < x)
            first = mid + 1;
        else
            last = mid-1;
    }
    return nullptr;
}
//Test
int main() {
	//int a[] {45, 1, 23, 5, 6, 9, 21, 100, 6, 8, 34, 6, 98, 4, 75, 13};
	//maopao(a,0,sizeof a/sizeof *a - 1);
	//kuaipai(a,0,sizeof a/sizeof *a - 1);
	//charu(a,0,sizeof a/sizeof *a - 1);
	//jiandan(a,0,sizeof a/sizeof *a - 1);
	//guibing(a,0,sizeof a/sizeof *a - 1);
	// build(a);
	// heapsort(a);
	// for (auto var : a)
	// 	cout << var << "  ";
 	int a[] = { 1,2,3,4,5,6,7,8 };
 	cout<<sizeof a / sizeof *a<<endl;
 	for (int x = 0; x <= 30; x++)
    {

        auto p = binary_search(a, sizeof a / sizeof *a, x);
        if (p != nullptr)
        	cout<<"a["<<p-a<<"] = "<<*p<<endl;
        else
            cout<<x<<" not found!"<<endl;
    }
	return  1 ;
}