各种排序算法的实现和比较

typedef int KeyType;
typedef struct
{
	KeyType key;
} DataType;

void insertSort(DataType a[], int n)
{
	DataType temp;
	int j = 0;

	for (int i = 1; i < n; i++)		//依次将a[1]~a[n-1]插入到前面已排序的序列
	{
		temp = a[i];			   
		for (j = i - 1; temp.key < a[j].key; --j) //从后往前查找待插入位置
			a[j + 1] = a[j];				      //向后移位
		a[j + 1] = temp;					      //复制到插入位置		
	}
}

void shellInsert(DataType data[], int len, int dk)
{
	int j;
	DataType temp;
	for (int i = dk; i < len; ++i)
	{
		if (data[i].key < data[i - dk].key)
		{
			temp = data[i];
			for (j = i - dk; j>=0 && temp.key<data[j].key; j -= dk)
			{
				data[j + dk] = data[j];
			}
			data[j + dk] = temp;
		}
	}
}

void shellSort(DataType data[], int len, int dlta[], int t)
{
	for (int k = 0; k<t; ++k)
	{
		shellInsert(data, len, dlta[k]);
	}
}

void bubbleSort(DataType data[], int len)
{
	int flag = 1;    
	DataType temp;

	for (int i = 0; i < len - 1 && flag == 1; ++i) 
	{
		flag = 0;                             
		for (int j = len - 1; j > i; --j)   //从前往后两两比较相邻元素的值
		{
			if (data[j - 1].key > data[j].key)
			{
				flag = 1;
				temp = data[j-1];
				data[j - 1] = data[j];
				data[j] = temp;
			}
		}
	}
}

int partition(DataType data[], int low, int high)
{
    DataType temp = data[low];     //取第一个元素作为基准
 
    while (low < high)
    {
        while (low < high && temp.key <= data[high].key) 
            --high;
        data[low] = data[high];
        
        while (low < high && temp.key >= data[low].key)
            ++low;
        data[high]=data[low];
    }
    
    data[low] = temp;   
    return low;
}

int partition(DataType data[], int low, int high)
{
	DataType privot = data[high];	    //取最后一位最为基准
	DataType tmp;
	int pos = low - 1;
    
	for (int j = low; j < high; ++j)
	{
		if (privot.key >= data[j].key)
		{
			++pos;
			tmp = data[pos];
			data[pos] = data[j];
			data[j] = tmp;
		}
	}
	tmp = data[pos + 1];
	data[pos + 1] = data[high];
	data[high] = tmp;
	return pos + 1;
}

void quickSort(DataType data[], int low, int high)
{
	if (low < high)
	{
		int pos = partition(data, low, high);

		if (pos-1 > low)
			quickSort(data, low, pos-1);
		if (pos+1 < high)
			quickSort(data, pos + 1, high);
	}
}

void selectSort(DataType data[], int len)
{
	DataType temp;
	int min;

	for (int i = 0; i < len - 1; ++i)
	{
		min = i;
		for (int j = i + 1; j < len; ++j)
		{
			if (data[j].key < data[min].key)
				min = j;
		}

		if (min != i)
		{
			temp = data[i];
			data[i] = data[min];
			data[min] = temp;
		}
	}
}

void siftDown(DataType data[], int curIdx, int maxIdx)
{
	int curPos = curIdx, leftIdx = 2 * curPos + 1;
	DataType tmp;

    //从上往下调整
    while (leftIdx <= maxIdx)
	{
		if (leftIdx < maxIdx && data[leftIdx].key < data[leftIdx + 1].key)
			++leftIdx;

		if (data[leftIdx].key > data[curPos].key)
		{
			tmp = data[leftIdx];
			data[leftIdx] = data[curPos];
			data[curPos] = tmp;

			curPos = leftIdx;
			leftIdx = 2 * curPos + 1;
		}
		else
			break;
	}
}

//创建大根堆
void createHeap(DataType data[], int len)
{
	for (int i = (len/2 - 1); i >= 0; --i)   //从最后一个分支开始调整
		siftDown(data, i, len - 1);
}

void heapSort(DataType data[], int len)
{
	DataType temp;
	int lastIndex = len - 1;

	createHeap(data, len);
    //用最后一个元素取代堆顶元素然后再调整，原堆顶元素放在末尾，即最大元素的放在末尾（从小到大排序）
	while (lastIndex > 0)
	{
		temp = data[0];
		data[0] = data[lastIndex];
		data[lastIndex] = temp;

		--lastIndex;
		siftDown(data, 0, lastIndex);
	}
}