数据结构初阶排序实现个人随堂笔记

周星新

已于 2023-10-28 20:40:50 修改

阅读量142

点赞数 2

文章标签：数据结构笔记算法

于 2023-10-26 21:49:23 首次发布

本文链接：https://blog.csdn.net/qq_68225689/article/details/134065478

版权

排序的实现

#include<string.h>
#include<assert.h>
#include<stdbool.h>

void Print(int* arr, int n);

void InsertSort(int* arr, int n);

void ShellSort(int* arr, int n);

void BubbleSort(int* arr, int n);

void HeapSort(int* arr, int n);

void SelectSort(int* arr, int n);

void CountSort(int* a, int n);

void QuickSort1(int* arr, int begin, int end);
int  Quick1(int* arr, int begin, int end);

void QuickSort2(int* arr, int begin, int end);
int  Quick2(int* arr, int begin, int end);

void QuickSort3(int* arr, int begin, int end);
int  Quick3(int* arr, int begin, int end);

void MergeSort(int* arr, int n);
void Merge(int* arr, int* temp, int begin, int end);

void QuickSort4(int* arr, int begin, int end);
int  Quick4(int* arr, int begin, int end);

void QuickSortNonR(int* arr, int left, int right);
void MergeSortNonR(int* arr, int n);


//非递归实现快速排序时栈的声明
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STTop(ST* ps);

int STSize(ST* ps);
bool STEmpty(ST* ps);

函数的实现

基础函数

void Print(int* arr,int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d	", arr[i]);
	}
	printf("\n");

}

void Swap(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}

插入排序的实现

void InsertSort(int* arr,int n)
{
	for (int i = 0; i < n-1; i++)
	{
		int end = i;
		int temp = arr[end + 1];
		while (end >=0)
		{
			if (arr[end] > temp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
				break;

		}
		arr[end+1] = temp;
	}
}

希尔排序的实现

void ShellSort(int* arr, int n)
{	
	int gap = n / 2;
	while (gap >= 1)
	{
		for (int i = 0; i < n-gap; i++)
		{
			int end = i;
			int temp = arr[gap +end];
			while (end >= 0)
			{
				if (arr[end] > temp)
				{
					arr[end +gap] = arr[end];
					end-=gap;
				}
				else
					break;

			}
			arr[end + gap] = temp;
		}
		gap = gap / 2;
	}
}

冒泡排序的实现

void BubbleSort(int* arr, int n)
{
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n - i-1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				Swap(arr+j, arr+j + 1);
			}
		}
	}
}

堆排序的实现

void Adjustdown(int* arr,int parent,int n)
{
	while (parent < n-1)
	{
		int child = parent * 2 + 1;//向上调整建大堆
		if (child + 1 < n - 1 && arr[child] < arr[child + 1])
			child++;
		if (child<n-1&&arr[parent] < arr[child])
			Swap(arr + parent, arr + child);
		parent = child;
	}

}
void HeapSort(int* arr, int n)
{
	for(int i=(n-1-1)/2;i>=0;i--)
	{
		Adjustdown(arr, i,n);
	}
	for (int i = n-1; i > 0; i--)
	{
		Swap(arr+0, arr + i);
		Adjustdown(arr, 0, i);
	}
}

搜索排序的实现

void SelectSort(int* arr, int n)
{
	int left = 0, right = n - 1;

	while (left < right)
	{
		int max = arr[left], min = arr[left];
		int maxi =right, mini = left;
		for (int i = left+1; i <= right; i++)
		{
			if (arr[i] > max)
			{
				max = arr[i];
				maxi = i;
			}
			if (arr[i] < min)
			{
				min = arr[i];
				mini = i;
			}
		}
		
		Swap(arr + left, arr + mini);
		if (maxi == left)
		{
			maxi = mini;
		}
		Swap(arr + right, arr + maxi);

		left++;
		right--;
	}
}

计数排序的实现

void CountSort(int* arr, int n)
{
	int min = arr[0], max = arr[0];
	for (int i = 0; i < n - 1; i++)
	{
		if (arr[i] < arr[min])
			min = i;
		if (arr[i] > arr[max])
			max = i;
	}
	int gap = arr[max]-arr[min];
	int* temp = (int*)malloc(sizeof(int) * (gap+1));
	memset(temp, 0, (gap + 1)*sizeof(int));
	for (int i = 0; i < n ; i++)
	{
		temp[arr[i] -arr[min]]++;
	}
	int j = 0;
	for (int i = 0; i < gap+1; i++)
	{
		while (temp[i]--)
		{
			arr[j++] = i + min;
		}
	}
	free(temp);
}

快速排序的三种实现
hoare法

void QuickSort1(int* arr, int begin, int end)
{
	if (begin >=end)
		return;
	int keyi = Quick1(arr, begin, end);
	QuickSort1(arr, begin, keyi - 1);
	QuickSort1(arr, keyi + 1, end);
}

int  Quick1(int* arr, int begin, int end)
{
	int key = begin;
	while (begin < end)
	{
		while (begin<end&&arr[end] >=arr[ key])
		{
			end--;
		}
		while (begin<end&&arr[begin] <= arr[key])
		{
			begin++;
		}
		Swap(&arr[begin], &arr[end]);
	}
	Swap(&arr[key], &arr[begin]);
	return begin;
}

挖坑法

void QuickSort2(int* arr, int begin, int end)
{
	if (begin >= end)
		return;
	int key = Quick2(arr, begin, end);
	QuickSort2(arr, begin, key - 1);
	QuickSort2(arr, key + 1, end);
}
int  Quick2(int* arr, int begin, int end)
{
	int hole = begin;
	int temp = arr[begin];
	while (begin < end)
	{
		while (begin < end && arr[end] >= temp)
		{
			end--;
		}
		Swap(&arr[hole], &arr[end]);
		hole = end;
		while (begin < end && arr[begin] <= temp)
		{
			begin++;
		}
		Swap(&arr[hole], &arr[begin]);
		hole = begin;
	}
	return hole;
}

前后指针法

void QuickSort3(int* arr, int begin, int end)
{
	if (begin >= end)
		return;
	int key = Quick3(arr, begin, end);
	QuickSort3(arr, begin, key - 1);
	QuickSort3(arr, key + 1, end);
}
int  Quick3(int* arr, int begin, int end)
{
	int key = arr[begin];
	int cur = begin, prev = begin + 1;
	while (prev <=end)
	{
		if (arr[prev] < key && ++cur < prev)
		{
			Swap(&arr[prev],& arr[cur]);
		}
		prev++;
	}
	Swap(&arr[cur], &arr[begin]);
	return cur;
}

快速排序的优化
三数取中

int TheMid(int* arr,int begin, int end, int mid)
{
	if (arr[begin] > arr[end])
	{
		if (arr[begin] < arr[mid])
			return begin;
		else if (arr[end] > arr[mid])
			return end;
		else
			return mid;
	}
	else
	{
		if (arr[end] <arr[mid])
			return end;
		else if (arr[begin] > arr[mid])
			return begin;
		else
			return mid;
	}
}

小区间的排序选择

int  Quick4(int* arr, int begin, int end)
{
	Swap(&arr[TheMid(arr, begin, end, (begin + end) / 2)], &arr[begin]);
	int hole = begin;
	int temp = arr[begin];
	while (begin < end)
	{
		while (begin < end && arr[end] >= temp)
		{
			end--;
		}
		Swap(&arr[hole], &arr[end]);
		hole = end;
		while (begin < end && arr[begin] <= temp)
		{
			begin++;
		}
		Swap(&arr[hole], &arr[begin]);
		hole = begin;
	}
	return hole;
}
void QuickSort4(int* arr, int begin, int end)
{
	if (begin >= end)
		return;
	if (end - begin + 1 > 10)
	{
		int key = Quick4(arr, begin, end);
		QuickSort4(arr, begin, key - 1);
		QuickSort4(arr, key + 1, end);
	}
	else
		InsertSort(arr + begin, end - begin + 1);
}

非递归实现快速排序

用栈的的实现
栈的声明

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

void STInit(ST* ps);
void STDestroy(ST* ps);
void STPush(ST* ps, STDataType x);
void STPop(ST* ps);
STDataType STTop(ST* ps);

int STSize(ST* ps);
bool STEmpty(ST* ps);

栈的实现

void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

void STPush(ST* ps, STDataType x)
{
	assert(ps);
	// 11:40
	if (ps->top == ps->capacity)
	{
		int newCapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newCapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}

		ps->a = tmp;
		ps->capacity = newCapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	--ps->top;
}

STDataType STTop(ST* ps)
{
	assert(ps);

	// 
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}

int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

void QuickSortNonR(int* arr, int left,int right)
{
	ST st;
	STInit(&st);

	STPush(&st, right);
	STPush(&st, left);
	while (!STEmpty(&st))
	{
		int begin = STTop(&st);
		STPop(&st);

		int end = STTop(&st);
		STPop(&st);

		int key = Quick1(arr, begin, end);

		if (key +1< end)
		{
			STPush(&st, end);
			STPush(&st, key+1);
		}
		if (left < key-1)
		{
			STPush(&st, key-1);
			STPush(&st, begin);
		}	
	}
	STDestroy(&st);
}

优化与非递归快速排序的测试

void testQuickSort4()
{
	int arr[] = { 6,1,5,9,4,5,666,9,12,3,99,82,2,78 };
	QuickSort4(arr, 0, sizeof(arr) / sizeof(int) - 1);
	Print(arr, sizeof(arr) / sizeof(int));
}
void testQuickSortNonR()
{
	int arr[] = { 6,1,5,9,4,5,666,9,12,3,99,82,2,78 };
	QuickSortNonR(arr, 0, sizeof(arr) / sizeof(int) - 1);
	Print(arr, sizeof(arr) / sizeof(int));
}



int main()
{
	testQuickSort4();
	testQuickSortNonR();
	return 0;
}

归并排序的递归实现

void Merge(int *arr,int *temp,int begin,int end)
{
	if (begin >= end)
		return ;
	int mid = (begin + end) / 2;
	Merge(arr, temp, begin, mid);
	Merge(arr, temp, mid+1, end);
	int begin1 = begin, end1 = mid;
	int begin2 = mid+1, end2 = end;
	int index = begin;
	while (begin1 <= end1&&begin2<=end2)
	{
		if (arr[begin1] < arr[begin2])
			temp[index++] = arr[begin1++];
		else
			temp[index++] = arr[begin2++];
	}
	while (begin1 <= end1)
	{
		temp[index++] = arr[begin1++];
	}
	while (begin2 <= end2)
	{
		temp[index++] = arr[begin2++];
	}
	memcpy(arr+begin, temp+begin, (end2 - begin + 1)*sizeof(int));
}
void MergeSort(int* arr, int n)
{
	int* temp = (int*)malloc(sizeof(int) * n);
	if (temp == NULL)
	{
		perror("malloc failed");
		exit(-1);
	}
	Merge(arr, temp, 0, n-1);
	free(temp);
}

归并排序的非递归实现

void MergeSortNonR(int* arr,int n)
{
	int* temp = (int*)malloc(sizeof(int) * n);
	if (temp == NULL)
	{
		perror("malloc fail");
		return;
	}
	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i+=2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			if (begin2 >=n)
				break;
			if (end2 >=n);
				end2 = n-1;
			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (arr[begin1] < arr[begin2])
					temp[index++] = arr[begin1++];
				else
					temp[index++] = arr[begin2++];
			}
			while (begin1 <= end1)
			{
				temp[index++] = arr[begin1++];
			}
			while (begin2 <= end2)
			{
				temp[index++] = arr[begin2++];
			}
			memcpy(arr + i, temp + i,(end2-i+1)*sizeof(int));
		}
		gap *= 2;
	}
	free(temp);
}

归并排序的测试

void testMergeort()
{
	int arr[] = { 6,1,5,9,4,5,666,9,12,3,99,82,2,78 };
	MergeSort(arr, sizeof(arr) / sizeof(int));
	Print(arr, sizeof(arr) / sizeof(int));
}

void testMergeSortNonR()
{
	int arr[] = { 6,1,5,9,4,5,666,9,12,3,99,82,2,78 };
	MergeSortNonR(arr,sizeof(arr) / sizeof(int));
	Print(arr, sizeof(arr) / sizeof(int));
}

int main()
{

	testMergeort();
	testMergeSortNonR();
	return 0;
}