常见的排序算法总结

1，冒泡排序

2，选择排序

3，直接插入排序

4，希尔排序

5，归并排序

6，堆排序

7，快速排序

下载链接

void swap(int *a,int *b)
{
	if (*a == *b)//防止出现a和b指向同一个位置的陷阱
	{
		return;
	}

	*a = (*a)^(*b);
	*b = (*a)^(*b);
	*a = (*a)^(*b);

// 	*a = (*a)+(*b);
// 	*b = (*a)-(*b);
// 	*a = (*a)-(*b);
}
/*
冒泡排序
*/

void BuddleSort(int list[],int len)
{
	if (list == NULL || len <= 1)
	{
		return ;
	}

	for (int i =0 ;i < len;i++)
	{
		for (int j = len - 1;j > i ;j --)
		{
			if (list[j] < list[j -1])
			{
				swap(&list[j],&list[j-1]);
			}
		}
	}
}
/*
选择排序
*/
void SelectSort(int list[],int len)
{
	if (list == NULL  || len <= 1)
	{
		return ;
	}

	for (int i = 0; i < len ; i++)
	{
		int temp = i;
		for (int j = i + 1; j < len; j++)
		{
			if (list[j] < list[temp])
			{
				temp = j;
			}
		}

		if (temp != i)
		{
			swap(&list[i],&list[temp]);
		}
	}
}
/*
直接插入排序
*/

void  InsetSort(int list[],int len)
{
	if (list == NULL || len <=1 )
	{
		return ;
	}

	for(int i = 1 ;i < len ;i ++)
	{
		if (list[i] < list[i -1])
		{
			int temp = list[i];
			int j = i - 1;
			for (; j >= 0 &&list[j] <temp;j--)
			{
				list[j+1] = list[j];
			}
			list[j + 1] = temp;
		}
	}
}
/*
希尔排序
*/

void ShellSort(int list[],int len)
{
	if (list == NULL || len <= 1)
	{
		return ;
	}

	int increment = len;

	do 
	{
		increment = increment /3 +1;

		for (int i = 0 + increment; i < len ; i ++)
		{
			if (list[i] < list[i - increment])
			{
				int temp = list[i];
				int j = i - increment;

				for (;j >= 0 &&list[j] > temp;j -= increment)
				{
					list[j + increment] = list[j];
				}

				list[j + increment] = temp;
			}
		}
	} while (increment > 1);
}
/*
归并排序
其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，
那么就可以很方便的将这二组数据进行排序。
*/
//合并两个有序的数组
void Merge(int list[],int Temp[],int begin,int mid,int end)
{
	int i = begin;
	int j = mid + 1;
	int index = 0;

	while(i <= mid && j <= end)
	{
		if (list[i] < list[j])
		{
			Temp[index++] = list[i++];
		}
		else
		{
			Temp[index++] = list[j++];
		}
	}

	while(i <= mid)
	{
		Temp[index++] = list[i++];
	}

	while(j <= end)
	{
		Temp[index++] = list[j++];
	}

	for (int i = 0 ; i < index;i++)
	{
		list[begin + i ] = Temp[i];
	}

}

void MSort(int list[],int Temp[],int begin,int end)
{
	if (begin < end)
	{
		int mid = begin + ((end - begin)>>1);//注意运算符的优先级
		MSort(list,Temp,begin,mid);//左边有序
		MSort(list,Temp,mid + 1,end);//右边有序 

		Merge(list,Temp,begin,mid,end);//再将二个有序数列合并  
	}
}

void MergeSort(int list[],int len)
{
	if (list == NULL || len <= 1)
	{
		return ;
	}

	int *Temp = new int[len];

	MSort(list,Temp,0,len -1);

	delete []Temp;
}


/*
堆排序
若想得到升序，则建立大顶堆，若想得到降序，则建立小顶堆。
*/
void AdjustHeap(int list[],int start,int end)
{
	int temp = list[start];
	//因为假设根结点的序号为0而不是1，所以i结点左孩子和右孩子分别为2i+1和2i+2
	for (int i = 2 * start + 1; i <= end; i = i *2 + 1)
	{
		if (i < end && list[i] < list[i + 1])//i < end 不可以掉
		{
			i++;
		}
		if (temp >= list[i])//左右孩子中获胜者与父亲的比较
		{
			break;
		}

		list[start] = list[i];

		start = i;
	}

	list[start] = temp;
}


void HeapSort(int list[],int len)
{
	if (list == NULL || len <= 1)
	{
		return;
	}

	for (int i = len/2; i >= 0 ;i --)
	{
		AdjustHeap(list,i,len);
	}

	for (int i = len -1 ;i > 0 ; i --)
	{
		swap(&list[0],&list[i]);
		AdjustHeap(list,0,i -1);
	}
}


/*
快速排序
*/

int Partion(int list[],int low,int high)
{
	int pivotkey = list[low];

	while(low < high)
	{
		while(low < high && list[high] >= pivotkey)
			high--;

		swap(&list[low],&list[high]);

		while(low < high && list[low] <= pivotkey)
			low++;

		swap(&list[low],&list[high]);
	}

	return low;
}
void QSort(int list[],int begin,int end)
{
	int pivot;
	if(begin < end)
	{
		pivot = Partion(list ,begin, end);

		QSort(list,begin,pivot -1);
		QSort(list,pivot + 1,end);
	}
}
void QuickSort(int list[],int len)
{
	if (list == NULL || len <= 1)
	{
		return ;
	}

	QSort(list,0,len -1);
}