01C语言——排序算法及二分查找总结

1.选择排序

	思想：合适的位置放合适的数，拿出每一个元素与后面的元素进行比较，升序排列，先从第一个位置开始，
			一共需要排列n-1个位置。实现方式：为两层FOR循环第一层控制元素位置，第一层进行比较，
			即当前数据与后面的每个数据进行比较。

void SelectSort(int *a,int len)
{
	int i,j=0;
	for(i = 0;i < len -1;++i)
	{
		for(j = i+1;j < len;++j)
		{
			if(a[i]>a[j])
			{
				Swap(&a[i],&a[j]);
			}
		}
	}
}

2.冒泡排序

	思想：相邻的元素两两比较，小的在前，大的在后。每一次比较都是确定最后一个位置的元素，需要进行
			n-1个趟比较。实现方法：两层FOR循环，第一层控制比较的躺数，第二次相邻的两个元素进行比较
			（注意：每次确定的位置为最后一个位置）。

void BubbleSort(int *a,int len)
{
	int i ,j = 0;
	for(i=0;i< len-1;++i)
	{
		for(j= 0 ;j < len -i -1;++j)
		{
			if(a[j] > a[j+1])
			{
				Swap(&a[j],&a[j+1]);
			}
		}
	}
}

3.插入排序

	思想：与军训的站队（个头）的原理一样，默认队首第一个元素为队伍的头，后面的来的元素都与之前的
			元素进行比较。实现方式：两层循环，第一层为for下标为1即第二个元素开始，一直到最后一个元素。
			第二层循环为，while循环用来进行判断的插入的位置。

void InsertSort(int *a,int len)
{
	int i ,j,t =0;
	for(i = 1;i < len;++i)
	{
		t = a[i];
		j = i;

		while(j>0 && t < a[j-1])
		{
			a[j] = a[j-1];
			--j;
		}
		a[j] = t;
	}
}

4.快速排序

	思想：与之前的实现方式不一样，采用递归的方式进行。
	首先，要确定队伍的首元素的最后元素的位置以及一个基准值，一般队伍首元素为基准值。
	其次要是的基准值右面的元素都比其基准值大，左面的的元素比基准值小。
	之后：先从最后一个元素开始向前移动，直到遇到比基准值小的元素，把该元素的值给队首的位置。
	之后：从第一个元素开始向后移动，直到遇到比基准值大的元素，把该元素的的值给之前移动的队尾所在位置。
	.......直达i = j ，移动到相同的位置把基准值移动带i，j的位置（i，j的位置此时是相同的）。
	最后，调用递归循环执行以上操作。

void QuickSort(int *a,int begin,int end)
{
	if(begin > end)
	{
		return ;
	}
	int i = begin;
	int j = end;
	int key = a[i];
	while(i < j)
	{
		while(i < j && key <= a[j])
		{
			--j;
		}
		a[i] = a[j];
		while(i < j && key >= a[i])
		{
			++i;
		}
		a[j] = a[i];
	}
	a[i] = key;
	QuickSort(a,begin,j-1);
	QuickSort(a,j+1,end);
}

5.希尔排序

	思想：是插入排序的扩展。
			每次对对整个子链进行除以2，把每个子列当用插入算法进行排序。

void ShellSort(int *a,int len)
{
	int i,j,inc = 0;
	for(inc = len/2;inc>0;inc /= 2)
	{
		for(i = inc;i < len;i++)
		{
			int t = a[i];
			j = i;
			while(j >= inc && t < a[j-inc])
			{
				a[j] = a[j-inc];
				j -= inc;
			}
			a[j] = t;
		}
	}
}

6.二分查找

函数参数：数组的首地址，数组的长度，查找的数字。
函数返回值：返回该数字的下标；如果不在数组中则返回-1。

int two_find(int *a,int len ,int num)
{
	int i = 0;
	int j = len -1;
	int mid = 0;
	while(i <= j)
	{
		mid = (i + j)/2;
		if(a[mid] > num)
		{
			j = mid - 1;
		}
		else if(a[mid] < num)
		{
			i = mid + 1;
		}
		else
		{
			break;
		}
	}
	if(mid <= len)
	{
		return mid;
	}
	else
	{
		return -1;
	}
}

总结：

 1.时间复杂度：
 select_sort = bubble_sort = insert_sort = O(n^2) > O(nlogn)   = quick_sort
 2.算法稳定性：
 什么是稳定性：
  所谓稳定性，就是待排序的序列中相同数值的元素的相对位置是否发生了改变，如果没有
  发生改变则说明该算法是稳定，反之则为不稳定。
  稳定：插入和冒泡；
  不稳定：选择和快速。

代码：

#include <stdio.h>
#include <stdlib.h>
//交换
int Swap(int *a,int *b)
{
	int t = *a;
	*a = *b;
	*b = t;
	return 0;
}
//选择排序
//接口为一维数组地址，和数组长度
void SelectSort(int *a,int len)
{
	int i,j=0;
	for(i = 0;i < len -1;++i)
	{
		for(j = i+1;j < len;++j)
		{
			if(a[i]>a[j])
			{
				Swap(&a[i],&a[j]);
			}
		}
	}
}
//冒泡排序
void BubbleSort(int *a,int len)
{
	int i ,j = 0;
	for(i=0;i< len-1;++i)
	{
		for(j= 0 ;j < len -i -1;++j)
		{
			if(a[j] > a[j+1])
			{
				Swap(&a[j],&a[j+1]);
			}
		}
	}
}
//插入排序
void InsertSort(int *a,int len)
{
	int i ,j,t =0;
	for(i = 1;i < len;++i)
	{
		t = a[i];
		j = i;

		while(j>0 && t < a[j-1])
		{
			a[j] = a[j-1];
			--j;
		}
		a[j] = t;
	}
}
//快速排序
//接口为一维数组地址，首元素的下标，尾元素的下标
void QuickSort(int *a,int begin,int end)
{
	if(begin > end)
	{
		return ;
	}
	int i = begin;
	int j = end;
	int key = a[i];
	while(i < j)
	{
		while(i < j && key <= a[j])
		{
			--j;
		}
		a[i] = a[j];
		while(i < j && key >= a[i])
		{
			++i;
		}
		a[j] = a[i];
	}
	a[i] = key;
	QuickSort(a,begin,j-1);
	QuickSort(a,j+1,end);
	
}
//希尔排序
void ShellSort(int *a,int len)
{
	int i,j,inc = 0; 
	for(inc = len/2;inc>0;inc /= 2)
	{
		for(i = inc;i < len;i++)
		{
			int t = a[i];
			j = i;
			while(j >= inc && t < a[j-inc])
			{
				a[j] = a[j-inc];
				j -= inc;
			}
			a[j] = t;
		}
	}
}
//二分查找
int two_find(int *a,int len ,int n)
{
	int i = 0;
	int j = len -1;
	int mid = 0;
	while(i <= j)
	{
		mid = (i + j)/2;
		if(a[mid] > n)
		{
			j = mid - 1;
		}
		else if(a[mid] < n)
		{
			i = mid + 1;
		}
		else
		{
			break;
		}
	}
	if(mid <= len)
	{
		return a[mid];
	}
	else
	{
		return -1;
	}
}
//打印模块
void PrintfArray(int *a,int len)
{
	int i = 0;
	for(i = 0;i < len;++i)
	{
		printf("%d ",a[i]);
	}
	printf("\n");
}

int main(int argc, const char *argv[])
{
	int a[] = {1,3,4,7,2,5,6,9,8,0};
	int len = sizeof(a)/sizeof(a[0]);
	//SelectSort(a,len);
	//BubbleSort(a,len);
	//InsertSort(a,len);
	//QuickSort(a,0,9);
	ShellSort(a,len);
	
	PrintfArray(a,len);
	return 0;
}