数据结构之排序算法

#include<iostream>
using namespace std;
#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){
				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 0;
}