数据结构——各种排序算法

各种排序算法

#include<iostream>
#include<stdlib.h>
using namespace std;

typedef int ElemType;

//直接插入排序 
void InsertSort(ElemType A[], int n)
{
	int i, j;
	for(i = 2; i <= n; i++)		//依次从第二个元素开始插入到前面已排序的元素 
	{
		if(A[i] < A[i-1])
		{
			A[0] = A[i];
			for(j = i-1; A[0] < A[j]; j--)		//从后往前查找插入位置 
				A[j+1] = A[j];
			A[j+1] = A[0];					//复制到插入位置 
		}
		
	}
}


//折半插入排序 
void InsertBSort(ElemType A[], int n)
{
	int i, j, low, high, mid;
	for(i = 2; i < n; i++)
	{
		A[0] = A[i];
		low = 1; 
		high = i-1;
		while(low <= high)
		{
			mid = (low + high) / 2;
			if(A[0] < A[mid])
				mid = high-1;
			else
				low = mid+1;
		}
		for(j = i-1; j >= high+1; j--)
			A[j+1] = A[j];
		A[high+1] = A[0];
	}
}

//交换排序——冒泡排序 
void BubbleSort(ElemType A[], int n)
{
	int i, j, flag,temp;
	for(i = 0; i < n-1; i++)
	flag = false;		//表明本趟是否发生交换的标志 
	for(j = n-1; j > i; j--)	//从最后一个数开始 
	{
		if(A[j] < A[j-1])		//如果后面的数大于前面，则交换 
		{	
			temp = A[j];
			A[j] = A[j-1];
			A[j-1] = temp;
			flag = true;		//标志位为真 
		}
		if(flag == false)		//本趟遍历后没有发生交换，说明已有序 
			return;
	}
	
}

//交换排序——快速排序 
//一次划分
int Partition(ElemType A[], int low, int high)
{
	ElemType pivot = A[low];		//把当前表的第一给元素设为枢轴，对表进行划分 
	while(low < high)				//循环跳出条件 
	{
		while(low < high && A[high] >= pivot)
			--high;
		A[low] = A[high];			//将比数轴小的值移到左端 
		while(low < high && A[low] <= pivot)
			++low;
		A[high] = A[low];			//将比枢轴大的值移到右端 
	} 
	A[low] = pivot;					//枢轴元素最终位置 
	return low;						//返回枢轴元素最终位置 
}

//快速排序
int QuickSort(ElemType A[], int low, int high)
{
	if(low < high)
	{
		int pivotpos = Partition(A, low, high);
		QuickSort(A, low, pivotpos-1);
		QuickSort(A, pivotpos+1, high);
	}
}


//简单选择排序 
void SelectSort(ElemType A[], int n)
{
	int i, j, min, temp;
	for(i = 0; i < n-1; i++)
	{
		min = i;		//记录最小元素的位置 
		for(j = i+1; j < n; j++)
		{
			if(A[j] < A[i])
				min = j;
			if(min != i)
			{
				temp = A[min];
				A[min] = A[i];
				A[i] = A[min];
			}
			
		}
	}
}

//堆排序
//建立大根堆 
void AdjustDown(ElemType A[], int k, int len)
{
	int i;
	for(i = 2*k; i <= len; i*=2)
	{
		if(i < len && A[i] < A[i+1])
			i++;
		if(A[0] > A[i])
			break;
		else
		{
			A[k] = A[i];
			k = i;
		}
	}
	A[0] = A[k];	
}

void BuildMaxHeap(ElemType A[], int len)
{
	int i;
	for(int i = len/2; i > 0; i--)
		AdjustDown(A, i, len);
}

//双向冒泡排序
void DBubbleSort(ElemType A[], int n)
{
	int low = 0, high = n-1;
	bool flag = true;						//一趟冒泡排序元素是否交换的标志 
	while(low < high && flag)		//循环跳出条件 
	{
		flag = false;	 			//初始标志为false 
		for(int i = low; i < high; i++)		//从前往后起泡 
		{
			if(A[i] > A[i+1]){				//逆序 
				swap(A[i], A[i+1]);			//交换 
				flag = true;				//发生交换，标志置true 
			}
		}
		high--;								//上界-1 
		for(int j = high; j > low; j--)		//从后往前起泡 
		{
			if(A[j] < A[j-1])
			{
				swap(A[j], A[j-1]);
				flag = true;				
			}
		}
		low++;								//下界+1; 
	}
	
}


int main()
{
	
	return 0;
}