排序，查找算法 总结

1、二分查找

首先引用一下《编程珠玑》中的两句话： 

1. 尽管给了那么充裕的时间，只有大约10%的专业程序员能够写出正确的二分查找。
2. 尽管第一个二分查找程序于1946年就公布了，但是第一个没有bug的二分查找程序在1962年才出现。

二分查找有这么难吗？其实很简单，但要写出一个bug free的代码确实还是有一些困难。下面这些是自己写的几个函数

// 数组已排序，且没有重复，找到了返回下标，没找到返回-1

int BinarySearch(int data[],int length, int target)
{
	int start = 0;
	int end = length-1;

	int mid;
	while (start<=end)         //此处必须为<=,不能改为<,可以在{1,3,5,7,9}中查找9试试。
	{
		mid=(start+end)>>1;

		if (data[mid]==target)
		{
			return mid;
		}		
		else if (data[mid]<target)
			start = mid+1;
		else
			end = mid-1;
	}

	return mid;
}


// 数组已排序，且没有重复，找到了返回下标，没找到返回小于但最相近的数

int BinarySearch(int data[],int length, int target)
{
	int start = 0;
	int end = length-1;

	int mid;
	while (start<=end)         
	{
		mid=(start+end)>>1;

		if (data[mid]==target)
		{
			return mid;
		}		
		else if (data[mid]<target)
			start = mid+1;
		else
			end = mid-1;
	}

	return end;
}

// 数组已排序，且没有重复，找到了返回下标，没找到返回大于但最相近的数

int BinarySearch(int data[],int length, int target)
{
	int start = 0;
	int end = length-1;

	int mid;
	while (start<=end)         
	{
		mid=(start+end)>>1;

		if (data[mid]==target)
		{
			return mid;
		}		
		else if (data[mid]<target)
			start = mid+1;
		else
			end = mid-1;
	}

	return start;
}


// 数组已排序，且有重复，找到了返回下标，没找到返回-1

int BinarySearch(int data[],int length, int target)
{
	int start = 0;
	int end = length-1;

	int mid;
	while (start<=end)
	{
		mid=(start+end)>>1;

		if (data[mid]==target)
		{
			if (mid>0)
			{
				while (data[mid-1]==target)
				{
					mid--;
				}
			}
			
			return mid;
		}		
		else if (data[mid]<target)
			start = mid+1;
		else
			end = mid-1;
	}

	return -1;
}

2、插入排序

#include <stdlib.h>
#include <stdio.h>

void InsertSort(int* data, int length)
{
	for (int j=1;j<length;j++)
	{
		int key = data[j];
		int i=j-1;

		while (i>=0 && data[i]>key)
		{
			data[i+1]=data[i];
			i--;
		}

		data[i+1] = key;
	}
}


int main()
{
	int data[]={4,3,2,6,7,1};
	int length = sizeof(data)/sizeof(int);

	InsertSort(data,length);

	for (int i=0;i<length;i++)
	{
		printf("%d  ",data[i]);
	}


	return 0;
}

ref:《算法导论》

3、快速排序

#include<stdio.h>
#include <stdlib.h>

void swap(int *a, int *b)
{
	int temp=*a;
	*a=*b;
	*b=temp;
}

int Partition(int* data,int start, int end)
{
	if (data==NULL || start<0 || end<0 ||end<start)
	{
		printf("Invalid input!");
		exit(-1);
	}

	int pivot = data[end];
	int i=start-1;

	for (int j=start;j<end;j++)
	{
		if (data[j]<pivot)
		{
			i++;
			swap(&data[i],&data[j]);
		}
	}

	i++;
	swap(&data[i],&data[end]);

	return i; 

}



void QuickSort(int *data, int start, int end)
{
	int index = Partition(data,start,end);

	if (index>start)
	{
		QuickSort(data,start,index-1);
	}
	
	if (index<end)
	{
		QuickSort(data,index+1,end);
	}
	
}

int main()
{
	int data[]={8,7,10,9,3,5,6};
	int length=sizeof(data)/sizeof(int);

	QuickSort(data,0,length-1);

	for (int i=0;i<length;i++)
	{
		printf("%d\t",data[i]);
	}

	printf("\n");

	return 0;

}

ref:《算法导论》