排序算法

本文内容主要是各个排序算法的代码，主要有

交换排序类：冒泡排序、快速排序；

选择排序类：简单选择排序、堆排序；

插入排序类：直接插入排序、希尔排序；

归并排序类：归并排序。

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>

void BubbleSort(int Numbers[], int length);
void QuickSort(int Numbers[], int low, int high);
int Partition(int Numbers[], int low, int high);

void SelectSort(int Numbers[], int length);
void HeapSort(int Numbers[], int length);
void HeapAdjust(int Numbers[], int s, int m);

void InsertSort(int Numbers[], int length);
void ShellSort(int Numbers[], int length);

void MergeSort(int Numbers[], int length);
void MergeSort(int SrcNumbers[], int DestNumbers[], int low, int high);
void Merge(int SrcNumbers[], int DestNumbers[], int low, int mid, int high);
void Swap(int *num1, int *num2);
bool InvalidInput = true;

//冒泡排序
void BubbleSort(int Numbers[], int length)
{
	if (Numbers == NULL || length <= 0)
		return;
	int flag = 1;
	for (int i = 1; i < length && flag; i++)
	for (int j = length - 1; j >= i; j--)
	{
		flag = 0;
		if (Numbers[j] < Numbers[j - 1])
		{
			flag = 1;
			Swap(&Numbers[j], &Numbers[j - 1]);
		}
	}
}

//快速排序
void QuickSort(int Numbers[], int low, int high)
{
	if (Numbers == NULL)
		return;
	if (low < high)
	{
		int pivot = Partition(Numbers, low, high);
		QuickSort(Numbers, low, pivot - 1);
		QuickSort(Numbers, pivot + 1, high);
	}
}

int Partition(int Numbers[], int low, int high)
{
	if (Numbers == NULL)
	{
		InvalidInput = false;
		return 0;
	}
	/*int m = low + (high-low) / 2;
	if (Numbers[low] > Numbers[high])
	Swap(&Numbers[low], &Numbers[high]);
	if (Numbers[m] > Numbers[high])
	Swap(&Numbers[m], &Numbers[high]);
	if (Numbers[m] > Numbers[low])
	Swap(&Numbers[m], &Numbers[low]);*/
	int pivotkey = Numbers[low];
	int temp = pivotkey;
	while (low < high)
	{
		while (low < high && Numbers[high] >= pivotkey)
			high--;
		//Swap(&Numbers[low], &Numbers[high]);
		Numbers[low] = Numbers[high];
		while (low < high && Numbers[low] <= pivotkey)
			low++;
		//Swap(&Numbers[low], &Numbers[high]);
		Numbers[high] = Numbers[low];
	}
	Numbers[low] = temp;
	return low;
}

//简单选择排序
void SelectSort(int Numbers[], int length)
{
	if (Numbers == NULL || length <= 0)
		return;
	int min;
	for (int i = 0; i < length; i++)
	{
		min = i;
		for (int j = i + 1; j < length; j++)
		if (Numbers[j] < Numbers[min])
			min = j;
		if (i != min)
			Swap(&Numbers[i], &Numbers[min]);
	}
}
//堆排序
void HeapSort(int Numbers[], int length)
{
	int i;
	for (i = length / 2 - 1; i >= 0; i--)
		HeapAdjust(Numbers, i, length);

	for (i = length - 1; i > 0; i--)
	{
		Swap(&Numbers[i], &Numbers[0]);
		HeapAdjust(Numbers, 0, i - 1);
	}
}

void HeapAdjust(int Numbers[], int s, int m)
{
	int j;
	int temp = Numbers[s];
	for (j = 2 * s + 1; j < m + 1; j = 2 * j + 1)
	{
		if (j < m  && Numbers[j] < Numbers[j + 1])
			++j;
		if (temp > Numbers[j])
			break;
		Numbers[s] = Numbers[j];
		s = j;
	}
	Numbers[s] = temp;
}
//插入排序
void InsertSort(int Numbers[], int length)
{
	if (Numbers == NULL || length <= 0)
		return;
	int Temp = 0;
	int i, j;
	for (i = 1; i < length; i++)
	{
		Temp = Numbers[i];
		if (Numbers[i] < Numbers[i - 1])
		{
			for (j = i - 1; Numbers[j] > Temp && j >= 0; j--)
				Numbers[j + 1] = Numbers[j];
			Numbers[j + 1] = Temp;
		}
	}
}
//希尔排序
void ShellSort(int Numbers[], int length)
{
	if (Numbers == NULL || length <= 0)
		return;
	int Temp = 0;
	int i, j, Increasment = length;
	do
	{
		Increasment = Increasment / 3 + 1;
		for (i = Increasment; i < length; i++)
		{
			Temp = Numbers[i];
			if (Numbers[i] < Numbers[i - Increasment])
			{
				for (j = i - Increasment; Numbers[j] > Temp && j >= 0; j -= Increasment)
					Numbers[j + Increasment] = Numbers[j];
				Numbers[j + Increasment] = Temp;
			}
		}
	} while (Increasment>1);
}

#define MAXSIZE 9
//归并排序
void MergeSort(int Numbers[], int length)
{
	MergeSort(Numbers, Numbers, 0, length - 1);
}

void MergeSort(int SrcNumbers[], int DestNumbers[], int low, int high)
{
	int TempNumbers[MAXSIZE];
	int mid;
	if (low == high)
		DestNumbers[low] = SrcNumbers[low];
	else
	{
		mid = (low + high) / 2;
		MergeSort(SrcNumbers, TempNumbers, low, mid);
		MergeSort(SrcNumbers, TempNumbers, mid + 1, high);
		Merge(TempNumbers, DestNumbers, low, mid, high);
	}
}

void Merge(int SrcNumbers[], int DestNumbers[], int low, int mid, int high)
{
	int i, j, l, k = low;
	for (i = low, j = mid + 1; i <= mid && j <= high; k++)
	if (SrcNumbers[i] < SrcNumbers[j])
	{
		DestNumbers[k] = SrcNumbers[i++];
	}
	else
	{
		DestNumbers[k] = SrcNumbers[j++];
	}
	while (i <= mid)
		DestNumbers[k++] = SrcNumbers[i++];
	while (j <= high)
		DestNumbers[k++] = SrcNumbers[j++];
}

void Swap(int *num1, int *num2)
{
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}

void TestBubble()
{
	int TestNums[] = { 50, 10, 17, 30, 50, 60, 70, 80, 90 };
	int nLen = sizeof(TestNums) / sizeof(int);
	printf("BubbleSort Sequence\n");
	BubbleSort(TestNums, nLen);
	for (int i = 0; i < nLen; i++)
		printf(" %d ", TestNums[i]);
	printf("\n");
}

void TestQuick()
{
	int TestNums2[] = { 50, 60, 79, 39, 58, 30, 25, 80, 16 };
	int nLen2 = sizeof(TestNums2) / sizeof(int);
	printf("QuickSort Sequence\n");
	QuickSort(TestNums2, 0, nLen2 - 1);
	for (int i = 0; i < nLen2; i++)
		printf(" %d ", TestNums2[i]);
	printf("\n");
}

void TestSelect()
{
	int TestNums1[] = { 50, 90, 40, 60, 50, 30, 70, 80, 10 };
	int nLen1 = sizeof(TestNums1) / sizeof(int);
	printf("SelectSort Sequence\n");
	SelectSort(TestNums1, nLen1);
	for (int i = 0; i < nLen1; i++)
		printf(" %d ", TestNums1[i]);
	printf("\n");
}

void TestHeap()
{
	int TestNums1[] = { 50, 90, 10, 60, 70, 40, 80, 30, 20 };
	int nLen1 = sizeof(TestNums1) / sizeof(int);
	printf("HeapSort Sequence\n");
	HeapSort(TestNums1, nLen1);
	for (int i = 0; i < nLen1; i++)
		printf(" %d ", TestNums1[i]);
	printf("\n");
}

void TestInsert()
{
	int TestNums1[] = { 50, 90, 40, 60, 50, 30, 70, 80, 10 };
	int nLen1 = sizeof(TestNums1) / sizeof(int);
	printf("InsertSort Sequence\n");
	InsertSort(TestNums1, nLen1);
	for (int i = 0; i < nLen1; i++)
		printf(" %d ", TestNums1[i]);
	printf("\n");
}

void TestShell()
{
	int TestNums2[] = { 19, 31, 25, 18, 23, 37, 36, 26, 82 };
	int nLen2 = sizeof(TestNums2) / sizeof(int);
	printf("ShellSort Sequence\n");
	ShellSort(TestNums2, nLen2);
	for (int i = 0; i < nLen2; i++)
		printf(" %d ", TestNums2[i]);
	printf("\n");
}

void TestMerge()
{
	int TestNums[] = { 50, 90, 17, 80, 30, 60, 30, 10, 60 };
	int nLen = sizeof(TestNums) / sizeof(int);
	printf("MergeSort Sequence\n");
	MergeSort(TestNums, nLen);
	for (int i = 0; i < nLen; i++)
		printf(" %d ", TestNums[i]);
	printf("\n");
}

int _tmain(int argc, _TCHAR* argv[])
{
	TestBubble();
	TestQuick();

	TestSelect();
	TestHeap();

	TestInsert();
	TestShell();

	TestMerge();
	return 0;
}