七种常用的排序

#include<stdio.h>
#include<stdlib.h>
#define TABLE_SIZE 19

typedef struct Node {
	int key;
	char value;
}Node,*NodePtr;

typedef struct SeqList {
	NodePtr elements;
	int length;
}SeqList,*ListPtr;

ListPtr initList(int* paraKeys, char* paraValues, int paraLength)
{
	ListPtr resultPtr = (ListPtr)malloc(sizeof(SeqList));
	resultPtr->length = paraLength;
	resultPtr->elements = (NodePtr)malloc(resultPtr->length * sizeof(Node));

	for (int i = 0; i < resultPtr->length; i++)
	{
		resultPtr->elements[i].key = paraKeys[i];
		resultPtr->elements[i].value = paraValues[i];
	}//off for

	return resultPtr;
}//off initList

void printList(ListPtr paraList)
{
	for (int i = 0; i < paraList->length; i++)
	{
		printf("%d\t", paraList->elements[i].key);
	}//off for
	printf("\r\n");
	for (int i = 0; i < paraList->length; i++)
	{
		printf("%c\t", paraList->elements[i].value);
	}//off for
}//off printList


//插入排序
void insertionSort(ListPtr paraPtr)
{
	Node tempNode;
	int j;
	for (int i = 2; i < paraPtr->length; i++)
	{
		tempNode = paraPtr->elements[i];
		for (j = i - 1; paraPtr->elements[j].key > tempNode.key; j--)
		{
			paraPtr->elements[j + 1] = paraPtr->elements[j];
		}//off for j

		paraPtr->elements[j + 1] = tempNode;
	}//off for i
}//off insertionSort

void insertionSortTest()
{
	int tempUnsortKeys[] = {-100,5,3,6,10,7,1,9};
	char tempContents[] = { 'n','i','t','e','s','c','f','w' };
	ListPtr tempList = initList(tempUnsortKeys, tempContents, 8);

	printf("\r\nBefore the sort:\r\n");
	printList(tempList);

	insertionSort(tempList);
	printf("\r\nAfter the sort:\r\n");
	printList(tempList);
}//off for insertionSortTest


//希尔排序
void shellSort(ListPtr paraList)
{
	Node tempNode;
	int i, j, k, p;
	int tempJumpArray[] = { 5,3,1 };
	int tempJump;
	for (i = 0; i < 3; i++)
	{
		tempJump = tempJumpArray[i];
		for (j = 0; j < tempJump; j++)
		{
			for (k = j + tempJump; k < paraList->length; k += tempJump)
			{
				tempNode = paraList->elements[k];
				for (p = k - tempJump; p >= 0; p -= tempJump)
				{
					if (paraList->elements[p].key > tempNode.key)
					{
						paraList->elements[p + tempJump] = paraList->elements[p];
					}//off if
					else
					{
						break;
					}//off else
				}//off for p

				paraList->elements[p + tempJump] = tempNode;
			}//off for k
		}//off for j
	}//off for i
}//off shellsort

void shellSortTest()
{
	int tempUnsortedKeys[] = { 5, 3, 6, 10, 7, 1, 9 };
	char tempContents[] = { 'i', 't', 'e', 's', 'c', 'f', 'w' };
	ListPtr tempList = initList(tempUnsortedKeys, tempContents, 7);

	printf("\r\nBefore shell sort:\r\n");
	printList(tempList);

	shellSort(tempList);
	printf("\r\nAfter shell sort:\r\n");
	printList(tempList);
}


//冒泡排序
void bubbleSort(ListPtr paraPtr)
{
	bool tempSwapped;
	Node tempNode;

	for (int i = paraPtr->length - 1; i > 0; i--)
	{
		tempSwapped = false;
		for (int j = 0; j < i; j++)
		{
			if (paraPtr->elements[j].key > paraPtr->elements[j + 1].key)
			{
				tempNode = paraPtr->elements[j + 1];
				paraPtr->elements[j + 1] = paraPtr->elements[j];
				paraPtr->elements[j] = tempNode;

				tempSwapped = true;
			}//off if
		}//off for j

		if (!tempSwapped)
		{
			printf("Premature\r\n");
			break;
		}//off if
	}//off for i
}//off bubbleSort

void bubbleSortTest()
{
	int tempUnsortedKeys[] = { 5, 3, 6, 10, 7, 1, 9 };
	char tempContents[] = { 'i', 't', 'e', 's', 'c', 'f', 'w' };
	ListPtr tempList = initList(tempUnsortedKeys, tempContents, 7);

	printf("\r\nBefore bubble sort:\r\n");
	printList(tempList);

	shellSort(tempList);
	printf("\r\nAfter bubble sort:\r\n");
	printList(tempList);
}//off bubbleSortTest


//快速排序
void  quickSortRecurssive(ListPtr paraPtr, int paraStart, int paraEnd)
{
	int tempPivot, tempLeft, tempRight;
	Node tempNodeForSwap;

	if (paraStart >= paraEnd)
	{
		return;
	}//off if

	tempPivot = paraPtr->elements[paraEnd].key;
	tempLeft = paraStart;
	tempRight = paraEnd - 1;

	while (true)
	{
		while ((paraPtr->elements[tempLeft].key < tempPivot) && (tempLeft < tempRight))
		{
			tempLeft++;
		}//off while

		while ((paraPtr->elements[tempRight].key >= tempPivot) && (tempLeft < tempRight))
		{
			tempRight--;
		}//off while

		if (tempLeft < tempRight)
		{
			tempNodeForSwap = paraPtr->elements[tempLeft];
			paraPtr->elements[tempLeft] = paraPtr->elements[tempRight];
			paraPtr->elements[tempRight] = tempNodeForSwap;
		}//off if
		else
		{
			break;
		}//off else
	}//off while

	if (paraPtr->elements[tempLeft].key > tempPivot)
	{
		tempNodeForSwap = paraPtr->elements[paraEnd];
		paraPtr->elements[paraEnd] = paraPtr->elements[tempLeft];
		paraPtr->elements[tempLeft] = tempNodeForSwap;
	}//off if
	else
	{
		tempLeft++;
	}//off else

	quickSortRecurssive(paraPtr, paraStart, tempLeft - 1);
	quickSortRecurssive(paraPtr, tempLeft + 1, paraEnd);
}//off quickSortRecurssive

void quickSortTest() {
	int tempUnsortedKeys[] = { 5, 3, 6, 10, 7, 1, 9 };
	char tempContents[] = { 'i', 't', 'e', 's', 'c', 'f', 'w' };
	ListPtr tempList = initList(tempUnsortedKeys, tempContents, 7);

	printf("\r\nBefore quick sort:\r\n");
	printList(tempList);

	quickSortRecurssive(tempList, 0, tempList->length - 1);
	printf("\r\nAfter quick sort:\r\n");
	printList(tempList);
}// off quickSortTest


//选择排序
void selectionSort(ListPtr paraPtr)
{
	Node tempNode;
	int tempIndexForSmallest;

	for (int i = 0; i < paraPtr->length - 1; i++)
	{
		tempNode = paraPtr->elements[i];
		tempIndexForSmallest = i;

		for (int j = i + 1; j < paraPtr->length; j++)
		{
			if (paraPtr->elements[j].key < tempNode.key)
			{
				tempNode = paraPtr->elements[j];
				tempIndexForSmallest = j;
			}//off if
		}//off for j

		paraPtr->elements[tempIndexForSmallest] = paraPtr->elements[i];
		paraPtr->elements[i] = tempNode;
	}//off for i
}//off selectionSorta

void selectionSortTest()
{
	int tempUnsortedKeys[] = { 5, 3, 6, 10, 7, 1, 9 };
	char tempContents[] = { 'i', 't', 'e', 's', 'c', 'f', 'w' };
	ListPtr tempList = initList(tempUnsortedKeys, tempContents, 7);

	printf("\r\nBefore selection sort:\r\n");
	printList(tempList);

	selectionSort(tempList);
	printf("\r\nAfter selection sort:\r\n");
	printList(tempList);
}//off selectionSortTest


//堆排序
void adjstHeap(ListPtr paraPtr, int paraStart, int paraLength)
{
	Node tempNode = paraPtr->elements[paraStart];
	int tempParent = paraStart;
	int tempKey = paraPtr->elements[paraStart].key;

	for (int tempChild = paraStart * 2 + 1; tempChild < paraLength; tempChild = tempChild * 2 + 1)
	{
		if (tempChild + 1 < paraLength)
		{
			if (paraPtr->elements[tempChild].key < paraPtr->elements[tempChild + 1].key)
			{
				tempChild++;
			}//off if
		}//off if

		if (tempKey < paraPtr->elements[tempChild].key)
		{
			paraPtr->elements[tempParent] = paraPtr->elements[tempChild];
			tempParent = tempChild;
		}//off if
		else 
		{
			break;
		}//off else
	}//off for

	paraPtr->elements[tempParent] = tempNode;
}//off adjstHeap

void heapSort(ListPtr paraPtr)
{
	Node tempNode;

	for (int i = paraPtr->length / 2 - 1; i >= 0; i--)
	{
		adjstHeap(paraPtr, i, paraPtr->length);
	}//off for

	for (int i = paraPtr->length - 1; i > 0; i--)
	{
		tempNode = paraPtr->elements[0];
		paraPtr->elements[0] = paraPtr->elements[i];
		paraPtr->elements[i] = tempNode;

		adjstHeap(paraPtr, 0, i);
	}//off for
}//off heapSort

void heapSortTest() {
	int tempUnsortedKeys[] = { 5, 3, 6, 10, 7, 1, 9 };
	char tempContents[] = { 'i', 't', 'e', 's', 'c', 'f', 'w' };
	ListPtr tempList = initList(tempUnsortedKeys, tempContents, 7);

	printf("\r\nBefore heap sort:\r\n");
	printList(tempList);

	heapSort(tempList);
	printf("\r\nAfter heap sort:\r\n");
	printList(tempList);
}// Of heapSortTest


//归并排序
void mergeSort(ListPtr paraPtr)
{
	int tempRow;
	int tempGroups;
	int tempActualRow;
	int tempNextRow = 0;
	int tempGroupNumber;
	int tempFirstStart, tempSecondStart, tempSecondEnd;
	int tempFirstIndex, tempSecondIndex;
	int tempNumCopied;
	int i;
	int tempSize;

	Node** tempMatrix = (Node**)malloc(2 * sizeof(Node*));
	tempMatrix[0] = (Node*)malloc(paraPtr->length * sizeof(Node));
	tempMatrix[1] = (Node*)malloc(paraPtr->length * sizeof(Node));
	for (i = 0; i < paraPtr->length; i++)
	{
		tempMatrix[0][i] = paraPtr->elements[i];
	}

	tempRow = -1;
	for (tempSize = 1; tempSize <= paraPtr->length; tempSize *= 2)
	{
		tempRow++;

		tempActualRow = tempRow % 2;
		tempNextRow = (tempRow + 1) % 2;

		tempGroups = paraPtr->length / (tempSize * 2);
		if (paraPtr->length % (tempSize * 2) != 0)
		{
			tempGroups++;
		}


		for (tempGroupNumber = 0; tempGroupNumber < tempGroups; tempGroupNumber++)
		{
			tempFirstStart = tempGroupNumber * tempSize * 2;
			tempSecondStart = tempGroupNumber * tempSize * 2 + tempSize;

			if (tempSecondStart > paraPtr->length - 1)
			{
				for (i = tempFirstStart; i < paraPtr->length; i++)
				{
					tempMatrix[tempNextRow][i] = tempMatrix[tempActualRow][i];
				}
				continue;
			}
			tempSecondEnd = tempGroupNumber * tempSize * 2 + tempSize * 2 - 1;
			if (tempSecondEnd > paraPtr->length - 1)
			{
				tempSecondEnd = paraPtr->length - 1;
			}

			tempFirstIndex = tempFirstStart;
			tempSecondIndex = tempSecondStart;
			tempNumCopied = 0;
			while ((tempFirstIndex <= tempSecondStart - 1)&& (tempSecondIndex <= tempSecondEnd))
			{
				if (tempMatrix[tempActualRow][tempFirstIndex].key <= tempMatrix[tempActualRow][tempSecondIndex].key)
				{

					tempMatrix[tempNextRow][tempFirstStart
						+ tempNumCopied] = tempMatrix[tempActualRow][tempFirstIndex];
					tempFirstIndex++;
				}
				else
				{
					tempMatrix[tempNextRow][tempFirstStart
						+ tempNumCopied] = tempMatrix[tempActualRow][tempSecondIndex];
					tempSecondIndex++;
				}
				tempNumCopied++;
			}

			while (tempFirstIndex <= tempSecondStart - 1)
			{
				tempMatrix[tempNextRow][tempFirstStart
					+ tempNumCopied] = tempMatrix[tempActualRow][tempFirstIndex];
				tempFirstIndex++;
				tempNumCopied++;
			}

			while (tempSecondIndex <= tempSecondEnd)
			{
				tempMatrix[tempNextRow][tempFirstStart
					+ tempNumCopied] = tempMatrix[tempActualRow][tempSecondIndex];
				tempSecondIndex++;
				tempNumCopied++;
			}
		}

	}

	for (i = 0; i < paraPtr->length; i++)
	{
		paraPtr->elements[i] = tempMatrix[tempNextRow][i];
	}
}

void mergeSortTest() {
	int tempUnsortedKeys[] = { 5, 3, 6, 10, 7, 1, 9 };
	char tempContents[] = { 'i', 't', 'e', 's', 'c', 'f', 'w' };
	ListPtr tempList = initList(tempUnsortedKeys, tempContents, 7);

	printf("\r\nBefore merge sort:\r\n");
	printList(tempList);

	mergeSort(tempList);
	printf("\r\nAfter merge sort:\r\n");
	printList(tempList);
}


int main()
{
	insertionSortTest();
	shellSortTest();
	bubbleSortTest();
	quickSortTest();
	selectionSortTest();
	heapSortTest();
	mergeSortTest();
	return 0;
}