数据结构的十九次作业：插入排序和希尔排序

        一：插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序也可以被视为一个构造有序序列的过程，它每步将一个待排序的纪录，按其关键码值的大小插入到前面已经排序的序列中的适当位置，直到全部插入排序完为止。

        二：希尔排序是插入排序的一种更高效的改进版本，也称为“缩小增量排序”。它通过将待排序的数组元素按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

插入排序和希尔排序都是基于插入的排序算法，但希尔排序通过引入增量的概念，对插入排序进行了优化，使得在大数据集上排序时效率更高。插入排序在数据规模较小时表现良好，特别是当数据已经部分有序时。希尔排序在平均情况下的时间复杂度低于插入排序，适用于大数据集的排序。在稳定性方面，插入排序是稳定的，而希尔排序则不是。

 

#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++) {
		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);
	}
}

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);
}

int main() {
	insertionSortTest();
	shellSortTest();
	return 1;
}

 

end