大二（上） 数据结构 各种内排序算法的实现及性能比较

最新推荐文章于 2023-09-27 20:53:10 发布
最新推荐文章于 2023-09-27 20:53:10 发布
阅读量3.3k 收藏 60
点赞数 12
分类专栏： 数据结构 文章标签： 排序算法 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43271844/article/details/85122788
版权

在这里插入图片描述

课本上的代码有问题，
这些代码调试了很久才出来的结果。
真的太心酸了。

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<time.h>
typedef int KeyType;
typedef int DataType;
typedef struct entry
{
	KeyType key;
	DataType data;
}Entry;
typedef struct list
{
	int n;
	Entry D[100];
}List;

int FindMin(List list, int startIndex)  //简单选择排序
{
	int i, minIndex = startIndex;
	for (i = startIndex + 1; i < list.n; i++)
	{
		if (list.D[i].key < list.D[minIndex].key)
			minIndex = i;
	}
	return minIndex;
}
void Swap(Entry* D, int i, int j)
{
	if (i == j)return;
	Entry temp = *(D + i);
	*(D + i) = *(D + j);
	*(D + j) = temp;
}
void SelectSort(List* list) //简单选择排序
{
	int minIndex, startIndex = 0;
	while (startIndex < list->n - 1)
	{
		minIndex = FindMin(*list, startIndex);
		Swap(list->D, startIndex, minIndex);
		startIndex++;
	}
}

void InsertSort(List *list) //直接插入排序
{
	int i, j;
	for (i = 1; i < list->n; i++)
	{
		Entry insertItem = list->D[i];
		for (j = i - 1; j >= 0; j--)
		{
			if (insertItem.key < list->D[j].key)
				list->D[j + 1] = list->D[j];
			else break;
		}
		list->D[j + 1] = insertItem;
	}
}

void BubbleSort(List* list, int n) //冒泡排序,n为待排序的个数
{
	int i, j;
	bool isSwap = false;
	for (i = n - 1; i > 0; i--)
	{
		for (j = 0; j < i; j++)
		{
			if (list->D[j].key > list->D[j + 1].key)
			{
				Swap(list->D, j, j + 1);
				isSwap = true;
			}
		}
		if (!isSwap) break;
	}
}



int Partition(List* list, int low, int high)
{
	int i = low, j = high + 1;
	Entry pivot = list->D[low];
	do
	{
		do i++; while (list->D[i].key < pivot.key); //i前进
		do j--; while (list->D[j].key > pivot.key); //j前进
		if (i < j) Swap(list->D, i, j);
	} while (i < j);
	Swap(list->D, low, j);
	return j;
}
void QuickSort(List* list, int low, int high) //快速排序算法
{
	int k;
	if (low < high)
	{
		k = Partition(list, low, high);
		QuickSort(list, low, k - 1);
		QuickSort(list, k + 1, high);
	}
}
void QuickSort(List *list)  //快速排序的调用函数
{
	QuickSort(list, 0, list->n - 1);
}


Entry temp[100];
long MergeSort(List* l)    //两路合并排序
{
	int size = 1, n1, n2;
	while (size < l->n) 
	{
		int k = 0;
		int low = 0;
		while (low + size <= l->n) 
		{
			n1 = size;
			if (low + size * 2 < l->n) 
			{
				n2 = size;
			}
			else 
			{
				n2 = l->n - low - size;
			}

			int i = low, j = low + n1;
			while (i <= low + n1 - 1 && j <= low + n1 + n2 - 1) 
			{
				if (l->D[i].key <= l->D[j].key) 
				{
					temp[k++] = l->D[i++];
				}
				else 
				{
					temp[k++] = l->D[j++];
				}
			}
			while (i <= low + n1 - 1) 
			{
				temp[k++] = l->D[i++];
			}
			while (j <= low + n1 + n2 - 1) 
			{
				temp[k++] = l->D[j++];
			}
			low += n1 + n2;
		}
		for (int i = 0; i < l->n; i++) 
		{
			l->D[i] = temp[i];
		}
		size *= 2;
	}
	return 0;
}



typedef struct maxheap  
{
	int n, MaxHeap;
	Entry D[100];
}MaxHeap;
void AdjustDown(List *list, int r, int j)
{
	int child = 2 * r + 1;
	Entry temp = list->D[r];
	while (child <= j) 
	{
		if ((child < j) && (list->D[child].key < list->D[child + 1].key)) 		         
			child++;
		if (temp.key >= list->D[child].key) 
			break;
		list->D[(child - 1) / 2] = list->D[child];
		child = 2 * child + 1;
	}
	list->D[(child - 1) / 2] = temp;
}
void HeapSort(List *list)   //堆排序
{
	for (int i = (list->n - 2) / 2; i > -1; i--)
		AdjustDown(list, i, list->n - 1);
	for (int i = list->n - 1; i > 0; i--) 
	{
		Swap(list->D, 0, i);
		AdjustDown(list, 0, i - 1);
	}
}



void Rand(List *list,int a[])  /*产生100以内的随机整数*/
{
	for (int i = 0; i < 100; i++) 
	{
		int b = rand() % 100;
		list->D[i].key = b;
		list->D[i].data = b;
		a[i] = b;
		printf("%d\t", list->D[i].key);
		list->n++;
	}
}

void RepeatRand(List *list,int *a)  /*复制100以内的随机整数*/
{
	for (int i = 0; i < 100; i++)
	{
		list->D[i].key = a[i];
		list->D[i].data = a[i];
	}
}

int main()
{
	List L1;
	L1.n = 0;
	int a[100];
	int n1;
	
	Rand(&L1,a); /*产生100以内的随机整数*/
	
	SelectSort(&L1);      //简单选择排序
	printf("\n\n\n简单选择排序\n");
	for (int i = 0; i < 100; i++)
		printf("%d\t", L1.D[i].data);

	printf("\n\n\n重新复制值：\n");
	RepeatRand(&L1,a);
	for (int i = 0; i < 100; i++)
		printf("%d\t", a[i]);
	printf("\n\n\n直接插入排序:\n");
	InsertSort(&L1);      //直接插入排序
	for (int i = 0; i < 100; i++)
		printf("%d\t", L1.D[i].data);	

	printf("\n\n\n重新复制值：\n");
	RepeatRand(&L1, a);
	for (int i = 0; i < 100; i++)
		printf("%d\t", a[i]);
	BubbleSort(&L1,100);  //冒泡排序
	printf("\n\n\n冒泡排序：\n");
	for (int i = 0; i < 100; i++)
		printf("%d\t", L1.D[i].data);
	
	printf("\n\n\n重新复制值：\n");
	RepeatRand(&L1, a);
	for (int i = 0; i < 100; i++)
		printf("%d\t", a[i]);
	QuickSort(&L1);       //快速排序的调用函数
	printf("\n\n\n快速排序：\n");
	for (int i = 0; i < 100; i++)
		printf("%d\t", L1.D[i].data);


	printf("\n\n\n重新复制值：\n");
	RepeatRand(&L1, a);
	for (int i = 0; i < 100; i++)
		printf("%d\t", a[i]);
	MergeSort(&L1);      //两路合并排序
	printf("\n\n\n两路合并排序：\n");
	for (int i = 0; i < 100; i++)
		printf("%d\t", L1.D[i].data);


	printf("\n\n\n重新复制值：\n");
	RepeatRand(&L1, a);
	for (int i = 0; i < 100; i++)
		printf("%d\t", a[i]);
	HeapSort(&L1);       //堆排序
	printf("\n\n\n堆排序：\n");
	for (int i = 0; i < 100; i++)
		printf("%d\t", L1.D[i].data);


	system("pause");
	return 0;
}

**

正式版

**

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<time.h>
using namespace std;
typedef int KeyType;
typedef int DataType;
typedef struct entry
{
	KeyType key;
	DataType data;
}Entry;
typedef struct list
{
	int n;
	Entry D[10000];
}List;

int FindMin(List list, int startIndex)  //简单选择排序
{
	int i, minIndex = startIndex;
	for (i = startIndex + 1; i < list.n; i++)
	{
		if (list.D[i].key < list.D[minIndex].key)
			minIndex = i;
	}
	return minIndex;
}
void Swap(Entry* D, int i, int j)
{
	if (i == j)return;
	Entry temp = *(D + i);
	*(D + i) = *(D + j);
	*(D + j) = temp;
}
void SelectSort(List* list) //简单选择排序
{
	int minIndex, startIndex = 0;
	while (startIndex < list->n - 1)
	{
		minIndex = FindMin(*list, startIndex);
		Swap(list->D, startIndex, minIndex);
		startIndex++;
	}
}

void InsertSort(List *list) //直接插入排序
{
	int i, j;
	for (i = 1; i < list->n; i++)
	{
		Entry insertItem = list->D[i];
		for (j = i - 1; j >= 0; j--)
		{
			if (insertItem.key < list->D[j].key)
				list->D[j + 1] = list->D[j];
			else break;
		}
		list->D[j + 1] = insertItem;
	}
}

void BubbleSort(List* list, int n) //冒泡排序,n为待排序的个数
{
	int i, j;
	bool isSwap = false;
	for (i = n - 1; i > 0; i--)
	{
		for (j = 0; j < i; j++)
		{
			if (list->D[j].key > list->D[j + 1].key)
			{
				Swap(list->D, j, j + 1);
				isSwap = true;
			}
		}
		if (!isSwap) break;
	}
}



int Partition(List* list, int low, int high)
{
	int i = low, j = high + 1;
	Entry pivot = list->D[low];
	do
	{
		do i++; while (list->D[i].key < pivot.key); //i前进
		do j--; while (list->D[j].key > pivot.key); //j前进
		if (i < j) Swap(list->D, i, j);
	} while (i < j);
	Swap(list->D, low, j);
	return j;
}
void QuickSort(List* list, int low, int high) //快速排序算法
{
	int k;
	if (low < high)
	{
		k = Partition(list, low, high);
		QuickSort(list, low, k - 1);
		QuickSort(list, k + 1, high);
	}
}
void QuickSort(List *list)  //快速排序的调用函数
{
	QuickSort(list, 0, list->n - 1);
}


Entry temp[10000];
long MergeSort(List* l)    //两路合并排序
{
	int size = 1, n1, n2;
	while (size < l->n) 
	{
		int k = 0;
		int low = 0;
		while (low + size <= l->n) 
		{
			n1 = size;
			if (low + size * 2 < l->n) 
			{
				n2 = size;
			}
			else 
			{
				n2 = l->n - low - size;
			}

			int i = low, j = low + n1;
			while (i <= low + n1 - 1 && j <= low + n1 + n2 - 1) 
			{
				if (l->D[i].key <= l->D[j].key) 
				{
					temp[k++] = l->D[i++];
				}
				else 
				{
					temp[k++] = l->D[j++];
				}
			}
			while (i <= low + n1 - 1) 
			{
				temp[k++] = l->D[i++];
			}
			while (j <= low + n1 + n2 - 1) 
			{
				temp[k++] = l->D[j++];
			}
			low += n1 + n2;
		}
		for (int i = 0; i < l->n; i++) 
		{
			l->D[i] = temp[i];
		}
		size *= 2;
	}
	return 0;
}


//堆排序
typedef struct maxheap  
{
	int n, MaxHeap;
	Entry D[10000];
}MaxHeap;
void AdjustDown(List *list, int r, int j)
{
	int child = 2 * r + 1;
	Entry temp = list->D[r];
	while (child <= j) 
	{
		if ((child < j) && (list->D[child].key < list->D[child + 1].key)) 		         
			child++;
		if (temp.key >= list->D[child].key) 
			break;
		list->D[(child - 1) / 2] = list->D[child];
		child = 2 * child + 1;
	}
	list->D[(child - 1) / 2] = temp;
}
void HeapSort(List *list)
{
	for (int i = (list->n - 2) / 2; i > -1; i--)
		AdjustDown(list, i, list->n - 1);
	for (int i = list->n - 1; i > 0; i--) 
	{
		Swap(list->D, 0, i);
		AdjustDown(list, 0, i - 1);
	}
}



void Rand(List *list,int a[])  /*产生100以内的随机整数*/
{
	for (int i = 0; i < 10000; i++) 
	{
		int b = rand() % 100;
		list->D[i].key = b;
		list->D[i].data = b;
		a[i] = b;
		printf("%d\t", list->D[i].key);
		list->n++;
	}
}

void RepeatRand(List *list,int *a)  /*复制100以内的随机整数*/
{
	for (int i = 0; i < 10000; i++)
	{
		list->D[i].key = a[i];
		list->D[i].data = a[i];
	}
}

int main()
{
	List L1;
	L1.n = 0;
	int a[10000];
	int n1;
	clock_t start, finish;
	Rand(&L1,a); /*产生100以内的随机整数*/
	

	start = clock();
	SelectSort(&L1);      //简单选择排序
	finish = clock();
	printf("\n\n\n简单选择排序\n");
	for (int i = 0; i < 10000; i++)
		printf("%d\t", L1.D[i].data);
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	
	RepeatRand(&L1, a);
	start = clock();
	printf("\n\n\n直接插入排序:\n");
	InsertSort(&L1);      //直接插入排序
	finish = clock();
	for (int i = 0; i < 10000; i++)
		printf("%d\t", L1.D[i].data);	
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	BubbleSort(&L1,100);  //冒泡排序
	finish = clock();
	printf("\n\n\n冒泡排序：\n");
	for (int i = 0; i < 10000; i++)
		printf("%d\t", L1.D[i].data);
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;
	
	RepeatRand(&L1, a);
	start = clock();
	QuickSort(&L1);       //快速排序的调用函数
	finish = clock();
	printf("\n\n\n快速排序：\n");
	for (int i = 0; i < 10000; i++)
		printf("%d\t", L1.D[i].data);
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;
	
	RepeatRand(&L1, a);
	start = clock();
	MergeSort(&L1);      //两路合并排序
	finish = clock();
	printf("\n\n\n两路合并排序：\n");
	for (int i = 0; i < 10000; i++)
		printf("%d\t", L1.D[i].data);
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;


	RepeatRand(&L1, a);
	start = clock();
	HeapSort(&L1);       //堆排序
	finish = clock();
	printf("\n\n\n堆排序：\n");
	for (int i = 0; i < 10000; i++)
		printf("%d\t", L1.D[i].data);
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	system("pause");
	return 0;
}

最终版

#include<stdio.h>
#include<iostream>
#include<stdlib.h>
#include<time.h>
const int  max = 25000;
using namespace std;
typedef int KeyType;
typedef int DataType;
typedef struct entry
{
	KeyType key;
	DataType data;
}Entry;
typedef struct list
{
	int n;
	Entry D[max];
}List;

int FindMin(List list, int startIndex)  //简单选择排序
{
	int i, minIndex = startIndex;
	for (i = startIndex + 1; i < list.n; i++)
	{
		if (list.D[i].key < list.D[minIndex].key)
			minIndex = i;
	}
	return minIndex;
}
void Swap(Entry* D, int i, int j)
{
	if (i == j)return;
	Entry temp = *(D + i);
	*(D + i) = *(D + j);
	*(D + j) = temp;
}
void SelectSort(List* list) //简单选择排序
{
	int minIndex, startIndex = 0;
	while (startIndex < list->n - 1)
	{
		minIndex = FindMin(*list, startIndex);
		Swap(list->D, startIndex, minIndex);
		startIndex++;
	}
}

void InsertSort(List *list) //直接插入排序
{
	int i, j;
	for (i = 1; i < list->n; i++)
	{
		Entry insertItem = list->D[i];
		for (j = i - 1; j >= 0; j--)
		{
			if (insertItem.key < list->D[j].key)
				list->D[j + 1] = list->D[j];
			else break;
		}
		list->D[j + 1] = insertItem;
	}
}

void BubbleSort(List* list, int n) //冒泡排序,n为待排序的个数
{
	int i, j;
	bool isSwap = false;
	for (i = n - 1; i > 0; i--)
	{
		for (j = 0; j < i; j++)
		{
			if (list->D[j].key > list->D[j + 1].key)
			{
				Swap(list->D, j, j + 1);
				isSwap = true;
			}
		}
		if (!isSwap) break;
	}
}



int Partition(List* list, int low, int high)
{
	int i = low, j = high + 1;
	Entry pivot = list->D[low];
	do
	{
		do i++; while (list->D[i].key < pivot.key); //i前进
		do j--; while (list->D[j].key > pivot.key); //j前进
		if (i < j) Swap(list->D, i, j);
	} while (i < j);
	Swap(list->D, low, j);
	return j;
}
void QuickSort(List* list, int low, int high) //快速排序算法
{
	int k;
	if (low < high)
	{
		k = Partition(list, low, high);
		QuickSort(list, low, k - 1);
		QuickSort(list, k + 1, high);
	}
}
void QuickSort(List *list)  //快速排序的调用函数
{
	QuickSort(list, 0, list->n - 1);
}


Entry temp[max];
long MergeSort(List* l)    //两路合并排序
{
	int size = 1, n1, n2;
	while (size < l->n) 
	{
		int k = 0;
		int low = 0;
		while (low + size <= l->n) 
		{
			n1 = size;
			if (low + size * 2 < l->n) 
			{
				n2 = size;
			}
			else 
			{
				n2 = l->n - low - size;
			}

			int i = low, j = low + n1;
			while (i <= low + n1 - 1 && j <= low + n1 + n2 - 1) 
			{
				if (l->D[i].key <= l->D[j].key) 
				{
					temp[k++] = l->D[i++];
				}
				else 
				{
					temp[k++] = l->D[j++];
				}
			}
			while (i <= low + n1 - 1) 
			{
				temp[k++] = l->D[i++];
			}
			while (j <= low + n1 + n2 - 1) 
			{
				temp[k++] = l->D[j++];
			}
			low += n1 + n2;
		}
		for (int i = 0; i < l->n; i++) 
		{
			l->D[i] = temp[i];
		}
		size *= 2;
	}
	return 0;
}


//堆排序
typedef struct maxheap  
{
	int n, MaxHeap;
	Entry D[max];
}MaxHeap;
void AdjustDown(List *list, int r, int j)
{
	int child = 2 * r + 1;
	Entry temp = list->D[r];
	while (child <= j) 
	{
		if ((child < j) && (list->D[child].key < list->D[child + 1].key)) 		         
			child++;
		if (temp.key >= list->D[child].key) 
			break;
		list->D[(child - 1) / 2] = list->D[child];
		child = 2 * child + 1;
	}
	list->D[(child - 1) / 2] = temp;
}
void HeapSort(List *list)
{
	for (int i = (list->n - 2) / 2; i > -1; i--)
		AdjustDown(list, i, list->n - 1);
	for (int i = list->n - 1; i > 0; i--) 
	{
		Swap(list->D, 0, i);
		AdjustDown(list, 0, i - 1);
	}
}


void Rand(List *list,int a[])  /*产生100以内的随机整数*/
{
	for (int i = 0; i < max; i++)
	{
		int b = rand() % 1000;
		list->D[i].key = b;
		list->D[i].data = b;
		a[i] = b;
		list->n++;
	}
}

void RepeatRand(List *list,int *a)  /*复制100以内的随机整数*/
{
	for (int i = 0; i < max; i++)
	{
		list->D[i].key = a[i];
		list->D[i].data = a[i];
	}
}

int main()
{
	List L1;
	L1.n = 0;
	int a[max];
	clock_t start, finish;
	Rand(&L1,a); /*产生100以内的随机整数*/

	start = clock();
	SelectSort(&L1);      //简单选择排序
	finish = clock();
	printf("简单选择排序\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;
	
	RepeatRand(&L1, a);
	start = clock();
	InsertSort(&L1);      //直接插入排序
	finish = clock();
	printf("\n直接插入排序:\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	BubbleSort(&L1,100);  //冒泡排序
	finish = clock();
	printf("\n冒泡排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;
	
	RepeatRand(&L1, a);
	start = clock();
	QuickSort(&L1);       //快速排序的调用函数
	finish = clock();
	printf("\n快速排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;
	
	RepeatRand(&L1, a);
	start = clock();
	MergeSort(&L1);      //两路合并排序
	finish = clock();
	printf("\n两路合并排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	RepeatRand(&L1, a);
	start = clock();
	HeapSort(&L1);       //堆排序
	finish = clock();
	printf("\n堆排序：\n");
	cout << "开始时间为:" << start << "	" << "结束时间为:" << finish << "   " << "持续时间为:" << (double)(finish - start) / CLOCKS_PER_SEC << endl;

	system("pause");
	return 0;
}
Thorold's Deer
关注
  • 12
    点赞
  • 踩
  • 60
    收藏
    觉得还不错? 一键收藏
  • 9
    评论
专栏目录
数据结构复习.zip 各种排序算法、大二上算法合集
12-27
在这个“数据结构复习.zip”压缩包中，你可能会找到一系列关于排序算法和其他基础算法的资料，这对于复习和深入理解这些概念非常有帮助。 首先，让我们详细讨论一下数据结构。数据结构是组织和存储数据的方式，它...
南邮数据结构实验四----各种内排序算法的实现及性能比较
Coding
01-23 9760
一、 实验目的和要求 内容： 验证教材的各种内排序算法。分析各种排序算法的时间复杂度。 要求： 使用随机数产生器产生大数据集合，运行上述各种排序算法，使用系统时钟测量各算法所需的实际时间，并进行比较。 这个程序一共包含两个模块，分别是单个排序算法的测试，和多个排序算法的共同测试比较。一共包含了8个排序算法。分别是简单选择排序，直接插入排序，冒泡排序，快速排序(调用系统栈),改进的
排序算法的详解和分析对比（详细讲解）
gongjunbox的博客
10-31 6969
排序算法各式各样，每种排序算法的思想也大同小异。读者应该深度了解每种算法的基本思想、排序每一步过程细节和每种排序的特性，看到特定的序列，应该立马想到最适合的排序方法。一些简单的排序算法中，虽然效率不高，但是在低数量规模情况下，就比如一万数量级以下，一般运行时间还能可以被人们所接受，零点几秒左右很难被察觉出来。但是如果到了十万数量级，排序就需要非常久的时间，可能会导致我们一些系统会出现误差，从而引起巨大的麻烦和问题。
数据结构(一)：几种常见排序算法比较
yanpenggong的博客
11-06 1368
排序 0. 常见排序算法效率比较 时间复杂度及稳定性比较 排序方法 平均方法 最优复杂度 最坏复杂度 辅助空间 稳定性 冒泡排序 O(n2n^2n2) O(n2n^2n2) O(n2n^2n2) O(1) 稳定 选择排序 O(n2n^2n2) O(n2n^2n2) O(n2n^2n2) O(1) 不稳定 插入排序 O(n2n^2n2) O(n2n^2n2) O(n2n^2n...
数据结构--常用比较排序
xd6905的博客
11-20 1773
目录 一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、堆排序 六、快速排序 6.1 key位置选择 6.2 一趟排序的方法 hoare版本 挖坑法 前后指针法 6.3 完整排序 七、归并排序 一、冒泡排序 每个新手第一个学的排序。 一趟：将当前位置的值与下一个比较，如果当前值大于下一个位置的值则交换（升序），一趟可以做到把最大值放在最后位置。 n个数n-1躺：第一趟比较n-1次，第二趟就只要比较n-2次，最后第...
十大经典排序算法（动图演示）
09-21 1789
0.1 算法分类比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。非比较类排序：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。0.2 算法复杂度0.3 相关概念稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。时间复杂度：对排序数据的总的操作次数。
数据结构课设_sdu_cs_大二_输者树外排序代码
04-26
在这个"数据结构课设_sdu_cs_大二_输者树外排序代码"项目中，我们聚焦于输者树（Loser Tree）这一特殊的数据结构，以及如何用它来执行外排序（External Sorting）。 输者树是一种用于高效比较多个元素的数据结构，...
大二上——数据结构_数据结构实验_
10-03
在这个“大二上——数据结构”实验中，我们将深入学习并实践一些基础且重要的数据结构，如栈、链表和队列。 1. **栈**（Stack）：栈是一种后进先出（LIFO, Last In First Out）的数据结构，类似于现实生活中的堆叠...
数据结构-大二上复习思维导图
11-11
总结来说，这个复习思维导图涵盖了数据结构的核心概念，从基础的查找方法到复杂的二叉树操作，再到各种排序算法。对于大二学生而言，深入理解和掌握这些知识是提高编程能力和解决问题能力的关键步骤。通过细致地研究...
江苏大学大二数据结构课程设计 导游系统的实现，成绩为优秀
02-25
在本项目中，江苏大学大二学生以数据结构为基础，实现了导游系统，该系统采用C语言作为开发语言，主要涉及后端技术。这个系统在答辩过程中表现优秀，得到了高分评价，表明其功能完善，代码质量高。以下是系统实现中...
各种内排序算法的实现及性能比较
JacobTsang的博客
06-17 1846
#include "1.h" int main() { List *list1,*list2,*list3,*list4,*list5,*list6; list1 = (List*)malloc(sizeof(List)); list2 = (List*)malloc(sizeof(List)); list3 = (List*)malloc(sizeof(List)); list4 =...
超详细的八大排序算法的各项比较以及各自的特点
热门推荐
柯南的博客
08-09 7万+
一、八大排序算法的总体比较 二、算法各自的特点（具体实现见后面博客） 1.快排 （1）算法思想 选择一个基准元素，将比基准元素小的元素放在其前面，比基准元素大的元素放在其后面，然后在将小于基准值元素的子数列和大于基准元素的子数列按原来的方法排序，直到整个序列有序; （2）优缺点 优点：极快数据移动少； 缺点：不稳定； （3）效率分析 此排序算法的效率在序列越乱的时候，效率越高...
数据结构与算法——内排序篇详解
♚焕蓝·未来的博客
05-16 1619
内排序是在排序整个过程中，待排序的所有记录全部被放置在内存中。外排序是由于排序记录个数太多，不能同时放置在内存，整个排序过程需要在内外存之间多次交换数据才能进行。这里介绍内排序的多种方法。
【数据结构】排序7——各种排序方法的比较
FishC的博客
11-07 1182
【数据结构】排序7——各种排序方法的比较
常见排序算法总结及性能比较
HanSion.Z
09-24 5415
常见排序算法总结及性能比较一.常见排序算法有哪些二. 插入排序1.直接插入排序2.希尔排序三.选择排序1.直接选择排序2.堆排序四.交换排序1.冒泡排序2.快速排序五.归并排序1.归并排序六.各算法性能比较 一.常见排序算法有哪些 二. 插入排序 1.直接插入排序 基本思想：插入排序是每次将一个待排序的记录，按照大小，插入到前面已经排好的有序区中适当的位置，直到将所有记录插入完位置。大概思想...
常见内排序实现汇总（含部分优化实现，基于链表的实现），以及性能比较
weixin_30287169的博客
07-07 328
这篇文章中包含了对一部分排序的实现，以及常见排序算法性能的比较。 插入排序(Insert Sort)部分 1. 折半插入排序(Binary Insert Sort)实现 2. 插入排序的链表实现 　　(1)改变结点值，不改变结点指针 　　(2)改变结点指针，不改变结点值 　　(3) 上面(2) 的简洁版 归并排序(Merge Sort)部分 1.归并排序实现 2.归并排序...
八种常见的排序算法实现以及其性能比较
qq_43837032的博客
10-06 1057
一，直接插入排序 其原理是，将序列分为一排序的有序子序列，和待排序的无序子序列。将待排序序列中的第一个元素插入到已排序子序列中去。使已排序序列+1，待排序序列-1。 /** * 直接插入排序 * */ public static void straightInsertionSort(int[] array) { for(int i = 1;i<array.length;i++) { int t = array[i]; int j; for(j = i-1;j>=
排序算法之（9）--八种常用排序算法效率对比
hiudawn
05-20 2万+
排序是数据处理中一种很重要也很常用的运算，一般情况下，排序操作在数据处理过程中要花费许多时间，为了提高计算机的运行效率，我们提出并不断改进各种各样的排序算法，这些算法也从不同角度展示了算法设计的重要原则和技巧。
【数据结构】八大排序算法-代码实现+复杂度分析+稳定性分析+总结
最新发布
chuxinchangcun的博客
09-27 938
注意：1.对于快速排序:如果加了三数取中 + 三路归并 最坏就不是O(N^2)2.为了绝对的速度选快排，为了省空间选堆排，为了稳定性选归并3.时间复杂度:O(N*logN)，额外空间复杂度低于O(N)，且稳定的基于比较的排序是不存在的。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值