排序

各种排序

1、冒泡排序
将数组的中的么一个数从头开始比较，找出最大的数，通过不断的交换，将最大数放入数组末尾。
将长度减少，再次遍历，直到数组填完。
2、冒泡排序——鸡尾酒排序
又称定向冒泡排序。
与冒泡排序的区别在于：冒泡只从低到高去比较，鸡尾酒排序不仅从低到高还从高到低去比较
3、选择排序
通过遍历，找到最小的数，将其放在数组开头。再从第二的位置开始遍历，找出第二小的数，放在数组第二个位置，直到数组的最后一个值
4、插入排序
适用范围：计算量小，基本排好序的
从数组第二个数开始遍历，记录这个位置的数据，在循环中判断它前面的数据是否大于它，若大于就将前一个数据覆盖到下一个位置中直到条件不成立，最后将保存的数据放到前一个位置实现替换。
5、二分插入排序
将数组分为两个部分，从左往右找，判断数据与中间数据的大小关系，小于中间数据则将右侧数据的下标记为中心数据下标-1，否则左侧下标记为中心数据下标+1，重新计算中心下标，直到左侧下标大于右侧，证明遍历结束
6、希尔排序：
对一组数进行分组，进行插入排序
7、归并排序
8、堆排序
9、快速排序

代码

1、冒泡排序

#include <stdio.h>

//交换
void myswap(int *a,int i,int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void myPrint(int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

void mySort(int *a, int len)
{
	int i,j;
	for(i = 0;i < len-1 ;i++)
	{
		for(j = 0;j < len-1-i;j++)
		{	
			if(a[j] > a[j+1])			//找到最大数沉底
				myswap(a,j+1,j);
		}
	}
}

void mySort1(int *a,int len)			//递归实现冒泡
{
	if(len == 1)
		return;
	int i;
	for(i =0;i < len-1;i++)
	{
		if(a[i] > a[i+1])
		{
			myswap(a,i,i+1);
		}
	}
	
	mySort1(a,len-1);
}

int main()
{
	int a[] = {9,8,7,6,5,4,25,3,2,1,0};
	int b[] = {9,8,7,6,5,4,13,3,2,1,0};
	int len = sizeof(a)/sizeof(a[0]);
	mySort(a, len);
	myPrint(a, len);
	
	mySort1(b, len);
	myPrint(b, len);
	
	return 0;
}

2、冒泡排序——鸡尾酒排序

#include <stdio.h>

void mySwap(int *a, int i, int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void myPrint(int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

void mySort(int *a, int len)
{
	int left = 0;
	int right = len-1;
	
	while(left < right)
	{
		int i;
		for(i = 0;i < right;i++)		//从左往右走，将最大的值往后压
		{
			if(a[i] > a[i+1])
			{
				mySwap(a,i,i+1);
			}
		}
		right--;
	
		for(i = right; i > 0;i--)		从右往左走，将最小的值往前压
		{
			if(a[i] < a[i-1])
			{
				mySwap(a,i,i-1);
			}
		}
		left++;
	}
}


void mySort1(int *a, int left, int right)			//利用递归来循环计算
{
	if (left >= right)
		return;
	
	int i;
	for (i = left; i < right; i++)  // 从左往右走，找最大元素沉底
	{
		if (a[i] > a[i+1])
		{
			mySwap(a, i, i+1);
		}
	}
	right--;
	
	for (i = right; i>left; i--)    // 从右往左走，找最小元素上浮
	{
		if (a[i] < a[i-1])
		{
			mySwap(a, i, i-1);
		}
	}
	left++;
	
	mySort1(a, left, right);
}

int main()
{
	int a[] = {3,1,5,2};
	int len = sizeof(a)/sizeof(a[0]);
	mySort(a, len);
	//mySort1(a, 0, len-1);
	myPrint(a, len);
	
	return 0;
}

3、选择排序

#include <stdio.h>

void mySwap(int *a, int i, int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}
void myPrint(int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

void mySort(int *a, int len)
{
	int i,j;
	for(i = 0;i < len -1;i++)				//从头到最后第二个数遍历
	{
		int min = i;
		for(j = i+1;j < len;j++)			//遍历从第i个数之后的数是否小于第i个数
		{									//如果小于就记录下标，便于交换
			if(a[min] > a[j])
			{
				min = j;
			}
		}
		if(min != i)						//如果min保存的值不是开始保存的值，说明他不是最小，要进行交换
		{
			mySwap(a,min,i);
		}
	}
}

int main()
{
	int a[] = {9,8,7,6,5,4,3,2,1,0};
	int len = sizeof(a)/sizeof(a[0]);
	mySort(a, len);
	myPrint(a, len);
	
	
	
	return 0;
}

4、插入排序

#include <stdio.h>

void myPrint(int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

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

int main()
{
	int a[] = {9,8,7,6,5,4,13,3,2,1,0};
	int len = sizeof(a)/sizeof(a[0]);
	mySort(a, len);
	myPrint(a, len);
	
	return 0;
}

5、二分插入排序

#include <stdio.h>

//交换
void myswap(int *a,int i,int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}

void myPrint(int *a,int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

void mySort(int *a,int len)
{
	int i;
	for(i = 0;i < len;i++)
	{
		int get = a[i];
		int left = 0;		//
		int right = i-1;
		
		while(left <= right)
		{
			int mid = (left+right)/2;
			if(a[mid] > get)
				right = mid - 1;
			else
				left = mid + 1;
		}
		
		int j;						//移位
		for(j = i-1;j >= left;j--)
		{
			a[j+1] = a[j];
			
		}
		a[left] = get;
	}
}

int main()
{
	int a[] = {3,1,5,2};
	int len = sizeof(a)/sizeof(a[0]);
	mySort(a, len);
	myPrint(a, len);
	
	return 0;
}

6、希尔排序：

#include <stdio.h>

void myPrint(int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

void mySort(int *a, int len)
{
	int i;
	int gap = 1;
	while(gap < len)			//每四个元素一组
	{
		gap = gap*3+1;
	}
	
	while(gap > 0)
	{
		for(i = gap;i < len;i++)		//按不同的gap进行插入排序
		{
			int get = a[i];
			int j = i - gap;
			while(j >= 0 && a[j] > get)
			{
				a[j+gap] = a[j];
				j -= gap;			
			}
			a[j+gap] = get;				//上面循环中最后j减去了gap,在下面要加上
		}
		
		printf("gap = %d\n",gap);
		myPrint(a, len);
		gap = gap/3;
	}	
}

int main()
{
	int a[] = {9,8,7,6,5,4,13,3,2,1,0};
	int len = sizeof(a)/sizeof(a[0]);
	mySort(a, len);
	myPrint(a, len);
	
	return 0;
}

7、归并排序

#include <stdio.h>

void mySwap(int *a,int i,int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] =tmp;
}

void myPrint(int *a,int len)
{
	int i;
	for(i = 0;i < len;i++)
	{
		printf("%4d",a[i]);
	}
	printf("\n");
}

//建堆
void shesty(int *a,int index,int len)
{
	int max = index;
	int lindex = index*2+1;			//左结点
	int rindex = index*2+2;			//右结点
	
	if(lindex < len && a[lindex]>a[max])
		max = lindex;
	if(rindex < len && a[rindex]>a[max])
		max = rindex;
	
	if(max != index)
	{
		mySwap(a,max,index);
		shesty(a,max,len);
	}
}

void mySort(int *a,int len)
{
	//建堆
	int i;
	for(i = len/2 - 1;i >= 0;i--)
	{
		shesty(a,i,len);
	}
		
	int count = len; 				//记录没将根结点覆盖到的个数
	//对堆排序
	for(i = len -1; i > 0;i--)
	{
		mySwap(a,0,i);
		count--;
		shesty(a,0,count);
	}
}

int main()
{
	int a[] = {9,8,4,6,5,7,13,3,2,1,0};
	int len = sizeof(a)/sizeof(a[0]);
	mySort(a,len);
	myPrint(a,len);

	return 0;
}

8、堆排序

#include <stdio.h>

void myPrint(int *a,int len)
{
	int i;
	for(i = 0;i < len;i++)
	{
		printf("%4d",a[i]);
	}
	printf("\n");
}

void add(int *a,int *tmp,int left,int right ,int mid)
{
	int i = left;
	int j = mid+1;
	int k = 0;
	
	while(i <= mid && j <= right)
	{
		if(a[i] < a[j])
			tmp[k++] = a[i++];
		else
			tmp[k++] = a[j++];
	}
	
	while(i <= mid)
	{
		tmp[k++] = a[i++];
	}
	
	while(j <= right)
	{
		tmp[k++] = a[j++];
	}
	
	for(i = 0;i < k;i++)
	{
		a[left+i] = tmp[i];
	}
}

void mySort(int *a,int left,int right,int *tmp)
{
	int mid =(left+right)/2;
	if(left < right)
	{
		mySort(a,left,mid,tmp);//左边归并
		mySort(a,mid+1,right,tmp);//右边归并
		add(a,tmp,left,right,mid);//合并两个数组
	}
}


int main()
{
	int a[] = {9,8,7,6,5,4,13,3,2,1,0};
	int len = sizeof(a)/sizeof(a[0]);
	int tmp[10];
	
	mySort(a,0,len-1,tmp);
	myPrint(a,len);
	
	return 0;
}

9、快速排序

#include <stdio.h>

void mySwap(int *a, int i, int j)
{
	int tmp = a[i];
	a[i] = a[j];
	a[j] = tmp;
}
void myPrint(int *a, int len)
{
	int i;
	for (i = 0; i < len; i++)
	{
		printf ("%4d", a[i]);
	}
	printf ("\n");
}

int partion(int *a, int left, int right)
{
	int pivot = a[right];    // 以最后一个元素作为基准值
	
	while(left < right)
	{
		while (a[left] <= pivot && left < right)
		{
			left++;
		}
		if (left < right)
		{
			a[right] = a[left];
			right--;
		}
		
		
		while (a[right] >= pivot && left < right)
		{
			right--;
		}
		
		if (left < right)
		{
			a[left] = a[right];
			left++;
		}
	}
	
	a[left] = pivot;
	
	return left;
}

void quickSort(int *a, int left, int right)
{
	if (left < right)
	{
		int pivotIndex = partion(a, left, right);    // 算基准值下标
		quickSort(a, left, pivotIndex-1);    // 对左半部分做快速排序
		quickSort(a, pivotIndex+1, right);   // 对右半部分做快速排序
	}
}

int main()
{
	int a[] = {5,8,6,0,9,4,3,2,1,7};
	int len = sizeof(a)/sizeof(a[0]);
	
	quickSort(a, 0, len-1);
	myPrint(a, len);
	
	return 0;
}