【作业】10.1: 常见的排序算法

#include <stdio.h>
#include <malloc.h>
#include <stdbool.h>

#define TABLE_SIZE 19

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

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

ListPtr initList(int* paraKeys, char* paraValues, int paraLength){
	int i;
	ListPtr resultPtr = (ListPtr)malloc(sizeof(struct SequentialList));
	resultPtr->length = paraLength;
	resultPtr->elements = (NodePtr)malloc(paraLength * sizeof(struct Node));
	for (i = 0; i < paraLength; i ++){
		//printf("setting key for index %d: %d and value: %c\r\n", i, paraKeys[i], paraValues[i]);
		resultPtr->elements[i].key = paraKeys[i];
		resultPtr->elements[i].value = paraValues[i];
	}

	return resultPtr;
}
void printList(ListPtr paraPtr) {
	int i;
	printf("(Keys, values)\r\n");
	for (i = 0; i < paraPtr->length; i ++) {
		printf("%d\t", paraPtr->elements[i].key);
	}
	printf("\r\n");
	for (i = 0; i < paraPtr->length; i ++) {
		printf("%c\t", paraPtr->elements[i].value);
	}
	printf("\r\n");
}
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];
		} 
		paraPtr->elements[j + 1] = tempNode;
	} 
}
void insertionSortTest() {
	int tempUnsortedKeys[] = { -100, 5, 3, 6, 10, 7, 1, 9 };
	char tempContents[] = { 'n', 'i', 't', 'e', 's', 'c', 'f', 'w' };
	ListPtr tempList = initList(tempUnsortedKeys, tempContents, 8);

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

	insertionSort(tempList);
	printf("\r\nAfter insertion sort:\r\n");
	printList(tempList);
}
void shellSort(ListPtr paraPtr) {
	Node tempNode;
	int tempJumpArray[] = { 5, 3, 1 };
	int tempJump;
	int p, i, j, k;
	for (i = 0; i < 3; i++) {
		tempJump = tempJumpArray[i];
		for (j = 0; j < tempJump; j++) {
			for (k = j + tempJump; k < paraPtr->length; k += tempJump) {
				tempNode = paraPtr->elements[k];
			
				for (p = k - tempJump; p >= 0; p -= tempJump) {
					if (paraPtr->elements[p].key > tempNode.key) {
						paraPtr->elements[p + tempJump] = paraPtr->elements[p];
					} else {
						break;
					} 
				} 
				paraPtr->elements[p + tempJump] = tempNode;
			} 
		} 
	} 
}
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;
	int i, j;
	for (i = paraPtr->length - 1; i > 0; i--) {
		tempSwapped = false;
		for (j = 0; j < i; j++) {
			if (paraPtr->elements[j].key > paraPtr->elements[j + 1].key) {
				// Swap.
				tempNode = paraPtr->elements[j + 1];
				paraPtr->elements[j + 1] = paraPtr->elements[j];
				paraPtr->elements[j] = tempNode;

				tempSwapped = true;
			} 
		} 
		if (!tempSwapped) {
			printf("Premature.\r\n");
			break;
		} 
	} 
}
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);
}


void quickSortRecursive(ListPtr paraPtr, int paraStart, int paraEnd) {
	int tempPivot, tempLeft, tempRight;
	Node tempNodeForSwap;
	
	if (paraStart >= paraEnd) {
		return;
	} 

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

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

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

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

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

	quickSortRecursive(paraPtr, paraStart, tempLeft - 1);
	quickSortRecursive(paraPtr, tempLeft + 1, paraEnd);
}
void quickSort(ListPtr paraPtr) {
	quickSortRecursive(paraPtr, 0, paraPtr->length - 1);
}
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);

	quickSort(tempList);
	printf("\r\nAfter quick sort:\r\n");
	printList(tempList);
}
void selectionSort(ListPtr paraPtr) {
	Node tempNode;
	int tempIndexForSmallest, i, j;

	for (i = 0; i < paraPtr->length - 1; i++) {
	
		tempNode = paraPtr->elements[i];
		tempIndexForSmallest = i;
		for (j = i + 1; j < paraPtr->length; j++) {
			if (paraPtr->elements[j].key < tempNode.key) {
				tempNode = paraPtr->elements[j];
				tempIndexForSmallest = j;
			} 
		} 
		paraPtr->elements[tempIndexForSmallest] = paraPtr->elements[i];
		paraPtr->elements[i] = tempNode;
	} 
}
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);
}
void adjustHeap(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++;
			} 
		}

		printf("The parent position is %d and the child is %d.\r\n", tempParent, tempChild);
		if (tempKey < paraPtr->elements[tempChild].key) {
			
			paraPtr->elements[tempParent] = paraPtr->elements[tempChild];
			printf("Move %d to position %d.\r\n", paraPtr->elements[tempChild].key, tempParent);
			tempParent = tempChild;
		} else {
			break;
		} 
	}

	printf("Move %d to position %d.\r\n", tempNode.key, tempParent);
	paraPtr->elements[tempParent] = tempNode;
}
void heapSort(ListPtr paraPtr) {
	Node tempNode;
	int i;

	for (i = paraPtr->length / 2 - 1; i >= 0; i--) {
		adjustHeap(paraPtr, i, paraPtr->length);
	} 
	for (i = paraPtr->length - 1; i > 0; i--) {
		tempNode = paraPtr->elements[0];
		paraPtr->elements[0] = paraPtr->elements[i];
		paraPtr->elements[i] = tempNode;

		adjustHeap(paraPtr, 0, i);
		printf("Round %d : ", (paraPtr->length - i));
		printList(paraPtr);
	} 
}
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);
}
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 1;
}