数据结构之排序

最新推荐文章于 2024-04-24 16:43:20 发布
最新推荐文章于 2024-04-24 16:43:20 发布
阅读量287 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BooleanWater/article/details/88877719
版权

1.插入排序

第一种：直接插入排序–稳定，时间复杂度为O（ n 2 n^2 n2）

直接插入排序示例代码一：有哨兵

void InsertSort(int a[], int size)
{//a[0]是哨兵
	int i,j;
	for (i = 2;i <= size;++i)
	{
		if (a[i] < a[i - 1])
		{
			a[0] = a[i];
			a[i] = a[i - 1];
			for (j = i - 2;a[0] < a[j];--j)
			{
				a[j + 1] = a[j];
			}
			a[j + 1] = a[0];
		}
	}
}
void main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	InsertSort(a,10);
	for (int i = 0;i < 11;i++)
		cout << a[i] << "  ";
}

直接插入排序示例代码二：重要

#include <iostream>

using namespace std;

void insert_sort(int a[], int n)
{
	int i, j, temp;

	for (i = 1;i < n;i++)
	{
		temp = a[i];
		for (j = i - 1;j >= 0 && temp < a[j];j--)
		{
			a[j + 1] = a[j];
		}
		a[j + 1] = temp;
	}
}

void print_array(int a[], int len)
{
	for (int i = 0;i < len;i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

int main(int agrc, char* argv[])
{
	int a[] = { 7,3,5,8,9,1,2,4,6 };
	cout << "before insert sort: ";
	print_array(a, 9);
	insert_sort(a, 9);
	cout << "after insert sort: ";
	print_array(a, 9);
	return 0;
}

第二种：折半插入排序–时间复杂度为O（ n 2 n^2 n2）

折半插入排序示例代码一：了解

#include <iostream>
using namespace std;
void InsertSort(int a[], int size)
{//a[0]是哨兵
	int i;
	int low, high,mid;
	for (i = 2;i <= size;++i)
	{
		a[0] = a[i];
		low = 1;high = i - 1;
		while (low <= high)
		{
			mid = (low + high) / 2;
			if (a[0] < a[mid])
				high = mid - 1;
			else
				low = mid + 1;
		}
		for (int z = i - 1;z >= high + 1;--z)
			a[z + 1] = a[z];
		a[high + 1] = a[0];
		
	}
}

void main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	InsertSort(a,10);
	for (int i = 0;i < 11;i++)
		cout << a[i] << "  ";
}

第三种：希尔排序–不稳定，时间复杂度O（ n 1.3 − 2 n^{1.3-2} n1.3−2）

希尔排序示例代码一：有暂存空间

#include <iostream>
using namespace std;
void ShellInsert(int L[],int length, int dk)
{//L[0]只是暂存单元，不是哨兵。当就<=0时，插入位置已找到
	int i,j;
	for (i = 1 + dk;i <= length;++i)
	{
		if (L[i] < L[i - dk])
		{
			L[0] = L[i];
			for (j = i - dk;(j > 0) && (L[0] < L[j]);j -= dk)
			{
				L[j + dk] = L[j];
			}
			L[j + dk] = L[0];
		}
	}
}
void ShellSort(int L[], int size, int dlta[], int t)
{
	int k;
	for (k = 0;k < t;k++)
	{
		ShellInsert(L,size, dlta[k]);
	}
}

void main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	int dk[] = {5,3,1};
	ShellSort(a, 10, dk, 3);
	for (int i = 0;i < 11;i++)
		cout << a[i] << "  ";
}

希尔排序示例代码二：重要

#include <iostream>

using namespace std;

void shell_sort(int a[], int len)
{
	int h, i, j, temp;
	for (h = len / 2;h > 0;h = h / 2)
	{
		for (i = h;i < len;i++)
		{
			temp = a[i];
			for (j = i - h;j >= 0 && temp < a[j];j -= h)
			{
				a[j + h] = a[j];
			}
			a[j + h] = temp;
		}
	}
}

void print_array(int a[], int len)
{
	for (int i = 0;i < len;i++)
	{
		cout << a[i] << " ";
	}
	cout << endl;
}

int main(int agrc, char* argv[])
{
	int a[] = { 7,3,5,8,9,1,2,4,6 };
	cout << "before shell sort: ";
	print_array(a, 9);
	shell_sort(a, 9);
	cout << "after shell sort: ";
	print_array(a, 9);
	return 0;
}

2.交换排序

第一种：起泡排序–稳定，时间复杂度为O（ n 2 n^2 n2）

起泡排序示例代码一：重要

#include <iostream>
using namespace std;
void BubbleSort(int a[], int n)
{
	bool flag;
	int i, j;
	for ( i = 0;i < n - 1;i++)
	{
		flag = false;
		for (j = n - 1;j>i;j--)
		{
			if (a[j - 1] > a[j])
			{
				swap(a[j - 1], a[j]);
				flag = true;
			}
		}
		if (flag == false)
			return;
	}
}
void main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	BubbleSort(a, 11);
	for (int i = 0;i < 11;i++)
		cout << a[i] << "  ";
}

第二种：快速排序–不稳定，时间复杂度O（ n l o g 2 n n{log_2{n}} nlog2​n）

快速排序示例代码一：有暂存空间

#include <iostream>
using namespace std;
int Partition(int L[], int low, int high)
{
	int pivotkey;
	L[0] = L[low];
	pivotkey = L[low];
	while (low < high)
	{
		while (low < high&&L[high] >= pivotkey)
			--high;
		L[low] = L[high];
		while (low < high&&L[low] <= pivotkey)
			++low;
		L[high] = L[low];
	}
	L[low] = L[0];
	return low;
}
void QSort(int L[], int low, int high)
{
	int pivotloc;
	if (low < high)
	{
		pivotloc = Partition(L, low, high);
		QSort(L,low,pivotloc-1);
		QSort(L, pivotloc + 1, high);
	}
}
void main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	QSort(a, 1, 10);
	for (int i = 0;i < 11;i++)
		cout << a[i] << "  ";
}

快速排序示例代码二：重要，随机产生比较对象

#include <iostream>
#include <time.h>
#include <algorithm>

using namespace std;

int RandomInRange(int start, int end)
{
	srand(time(NULL));
	return rand() % (end - start + 1) + start;
}

int Partition(int data[], int length, int start, int end)
{
	if (data == nullptr || length <= 0 || start < 0 || end >= length)
	{
		throw new std::exception("Invalid Parameters.");
	}
	int index = RandomInRange(start, end);
	swap(data[index], data[end]);

	int small = start - 1;
	for (index = start;index < end;++index)
	{
		if (data[index] < data[end])
		{
			++small;
			if (small != index)
			{
				swap(data[small], data[index]);
			}
		}
	}
	++small;
	swap(data[small], data[end]);
	return small;
}

void QuickSort(int data[],int length ,int start, int end)
{
	if (start == end)
	{
		return;
	}
	int index = Partition(data, length, start, end);
	if (index > start)
	{
		QuickSort(data, length, start, index - 1);
	}
	if (index < end)
	{
		QuickSort(data, length, index + 1, end);
	}
}

int main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	QuickSort(a, 11, 1, 10);
	for (int i = 0;i < 11;i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
	return 0;
}

快速排序示例代码三：重要，三点中值

#include <iostream>
#include <time.h>
#include <algorithm>
using namespace std;

int MidOfThree(int a[],int start, int end)
{
	int mid = start + (end - start) / 2;
	return a[start] > a[mid] ? (a[mid]>a[end]?mid:(a[start]>a[end]?end:start)) : (a[start]>a[end]?start:(a[mid]>a[end]?end:mid));
}

int Partition(int data[], int length, int start, int end)
{
	if (data == nullptr || length <= 0 || start < 0 || end >= length)
	{
		throw new exception("Invalid Parameters.");
	}
	int index = MidOfThree(data, start, end);
	swap(data[index], data[end]);
	int small = start - 1;
	for (index = start;index < end;++index)
	{
		if (data[index] < data[end])
		{
			++small;
			if (small != index)
			{
				swap(data[small], data[index]);
			}
		}
	}
	++small;
	swap(data[small], data[end]);
	return small;
}

void QuickSort(int data[], int length, int start, int end)
{
	if (start == end)
	{
		return;
	}
	int index = Partition(data, length, start, end);
	if (index > start)
	{
		QuickSort(data, length, start, index - 1);
	}
	if (index < end)
	{
		QuickSort(data, length, index + 1, end);
	}
}

void quick_sort(int a[], int length)
{
	QuickSort(a, length, 0, length - 1);
}

void main()
{
	int a[10] = { 0,111,233,14,10,45,13,56,17,1};
	quick_sort(a, 10);
	for (int i = 0;i < 10;i++)
		cout << a[i] << "  ";
	cout << endl;
	int b[11] = { 0,111,233,14,10,45,13,56,17,1,12 };
	quick_sort(b, 11);
	for (int i = 0;i < 11;i++)
		cout << b[i] << "  ";
	cout << endl;
	int c[8] = { 8,6,1,3,5,2,7,4 };
	quick_sort(c, 8);
	for (int i = 0;i < 8;i++)
		cout << c[i] << "  ";
	cout << endl;

}

快速排序示例代码四：一个函数

#include <iostream>

using namespace std;

void quick_sort(int a[], int low, int high)
{
	int i, j, pivot;
	if (low < high)
	{
		pivot = a[low];
		i = low;
		j = high;
		while (i < j)
		{
			while (i<j&&a[j]>=pivot)
				--j;
			if (i < j)
				a[i++] = a[j];
			while (i < j&&a[i] <= pivot)
				++i;
			if (i < j)
				a[j--] = a[i];
		}
		a[i] = pivot;
		quick_sort(a, low, i - 1);
		quick_sort(a, i + 1, high);
	}
}

int main(int agrc, char* argv[])
{
	int data[9] = { 54,38,96,23,15,72,60,45,83 };
	quick_sort(data, 0, 8);
	for (int i = 0;i < 9;i++)
	{
		cout << data[i] << " ";
	}
	return 0;
}

3.选择排序

第一种： 简单选择排序–不稳定L={2，2，1}->{1，2，2} O( n 2 n^2 n2)

简单选择排序示例代码一：重要

#include <iostream>
using namespace std;
void SelectSort(int A[], int n)
{
	int min,i,j;
	for (i = 0;i < n - 1;i++)
	{
		min = i;
		for (j = i + 1;j < n;j++)
			if (A[j] < A[min]) min = j;
		if (min != i)
			swap(A[i], A[min]);
	}
}
void main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	SelectSort(a, 11);
	for (int i = 0;i < 11;i++)
		cout << a[i] << "  ";
}

第二种：堆排序–不稳定 时间复杂度O( n l o g 2 n n{log_2{n}} nlog2​n)

堆排序示例代码一：a[0]是辅助空间，堆顶的序号为1

#include <iostream>

using namespace std;

#include <iostream>
using namespace std;
void HeapAdjustDown(int a[], int k, int len)//大根堆
{
	a[0] = a[k];
	for (int i = 2 * k;i < len;i *= 2)
	{
		if ((i + 1) < len&&a[i] < a[i + 1])
			i++;
		if (a[0] >= a[i])
			break;
		else
		{
			a[k] = a[i];
			k = i;
		}
	}
	a[k] = a[0];
}
void HeapSort(int a[], int len)
{
	for (int i = (len - 1) / 2;i > 0;i--)
	{
		HeapAdjustDown(a, i, len);
	}
	for (int j = len - 1;j > 1;j--)
	{
		swap(a[j], a[1]);
		HeapAdjustDown(a, 1, j );
	}
}
void main()
{
	int a[10] = { 0,111,233,14,10,45,13,56,17,1};
	HeapSort(a, 10);
	for (int i = 0;i < 10;i++)
		cout << a[i] << "  ";
}

堆排序示例代码二：堆顶的序号为0

#include <iostream>

using namespace std;

#include <iostream>
using namespace std;
void HeapAdjustDown(int a[], int k, int len)//大根堆
{
	int temp = a[k];
	for (int i = 2 * k + 1;i < len;i = 2 * i + 1)
	{
		if ((i + 1) < len&&a[i] < a[i + 1])
			i++;
		if (temp >= a[i])
			break;
		else
		{
			a[k] = a[i];
			k = i;
		}
	}
	a[k] = temp;
}
void HeapSort(int a[], int len)
{
	for (int i = (len - 2) / 2;i >= 0;i--)
	{
		HeapAdjustDown(a, i, len);
	}
	for (int j = len - 1;j >0;j--)
	{
		swap(a[j], a[0]);
		HeapAdjustDown(a, 0, j);
	}
}
void main()
{
	int a[10] = { 0,111,233,14,10,45,13,56,17,1};
	HeapSort(a, 10);
	for (int i = 0;i < 10;i++)
		cout << a[i] << "  ";
	cout << endl;
	int b[11] = { 0,111,233,14,10,45,13,56,17,1,12 };
	HeapSort(b, 11);
	for (int i = 0;i < 11;i++)
		cout << b[i] << "  ";
	cout << endl;
}

堆排序示例代码三：递归的方法，堆顶的序号为0

#include <iostream>

using namespace std;

int Left(int index) { return ((index << 1) + 1); }
int Right(int index) { return ((index << 1) + 2); }
void swap(int *a, int *b) { int temp = *a;*a = *b;*b = temp; }

void maxHeapify(int array[], int index, int heapSize)//大根堆
{
	int largest = 0;
	int left = Left(index);
	int right = Right(index);

	if ((left <= heapSize) && (array[left] > array[index]))
	{
		largest = left;
	}
	else
	{
		largest = index;
	}
	if ((right <= heapSize) && (array[right] > array[largest]))
	{
		largest = right;
	}
	if (largest != index)
	{
		swap(&array[index], &array[largest]);
		maxHeapify(array, largest, heapSize);
	}
}
void heap_sort(int array[], int length)
{
	for (int i = ((length - 2) >>1);i >= 0;i--)
	{
		maxHeapify(array, i, length-1);
	}
	for (int j = length - 1;j >0;j--)
	{
		swap(&array[j], &array[0]);
		maxHeapify(array, 0, j-1);
	}
}
void main()
{
	int a[10] = { 0,111,233,14,10,45,13,56,17,1};
	heap_sort(a, 10);
	for (int i = 0;i < 10;i++)
		cout << a[i] << "  ";
	cout << endl;
	int b[11] = { 0,111,233,14,10,45,13,56,17,1,12 };
	heap_sort(b, 11);
	for (int i = 0;i < 11;i++)
		cout << b[i] << "  ";
	cout << endl;
	int c[8] = { 45,68,20,39,88,97,46,59 };
	heap_sort(c, 8);
	for (int i = 0;i < 8;i++)
		cout << c[i] << "  ";
	cout << endl;

}

4.归并排序

第一种：归并排序–稳定 时间复杂度O( n l o g 2 n n{log_2{n}} nlog2​n)

归并排序示例代码一：要用户自己申请暂存空间

#include <iostream>
using namespace std;
void Merge(int a[],int b[], int low, int mid, int high)
{
	int i, j, k;
	for (k = low;k <= high;k++)
		b[k] = a[k];
	for (i = low, j = mid + 1, k = i;i <= mid&&j <= high;k++)
	{
		if (b[i] <= b[j])
			a[k] = b[i++];
		else
			a[k] = b[j++];
	}
	while (i <= mid) a[k++] = b[i++];
	while (j <= high) a[k++] = b[j++];

}
void MergeSort(int a[],int b[], int low, int high)
{
	if (low < high)
	{
		int mid = (low + high) / 2;
		MergeSort(a,b,low,mid);
		MergeSort(a,b,mid+1,high);
		Merge(a,b,low,mid,high);
	}
}
void main()
{
	int a[11] = { 0,1,233,4,2,45,3,56,7,1,12 };
	int b[11];
	MergeSort(a,b,0,10);
	for (int i = 0;i < 11;i++)
		cout << a[i] << "  ";
}

归并排序示例代码二：不需要用户自己申请暂存空间，智能版

#include <iostream>

using namespace std;

void Merge(int a[], int tmp[], int lPos, int rPos, int rEnd)
{
	int i, lEnd, NumElements, tmpPos;
	lEnd = rPos - 1;
	tmpPos = lPos;
	NumElements = rEnd - lPos + 1;
	while (lPos <= lEnd&&rPos <= rEnd)
	{
		if (a[lPos] <= a[rPos])
		{
			tmp[tmpPos++] = a[lPos++];
		}
		else
		{
			tmp[tmpPos++] = a[rPos++];
		}
	}
	while (lPos <= lEnd)
	{
		tmp[tmpPos++] = a[lPos++];
	}
	while (rPos <= rEnd)
	{
		tmp[tmpPos++] = a[rPos++];
	}
	for (i = 0;i < NumElements;i++, rEnd--)
	{
		a[rEnd] = tmp[rEnd];
	}
}

void msort(int a[], int tmp[], int low, int high)
{
	if (low < high)
	{
		int middle = (low + high) / 2;
		msort(a, tmp, low, middle);
		msort(a, tmp, middle + 1, high);
		Merge(a, tmp, low, middle + 1, high);
	}
}

void merge_sort(int a[], int len)
{
	int *tmp = NULL;
	tmp = new int[len];
	if (tmp != NULL)
	{
		msort(a, tmp, 0, len - 1);
		delete[]tmp;
	}
}

void main()
{
	int a[10] = { 0,111,233,14,10,45,13,56,17,1};
	merge_sort(a, 10);
	for (int i = 0;i < 10;i++)
		cout << a[i] << "  ";
	cout << endl;
	int b[11] = { 0,111,233,14,10,45,13,56,17,1,12 };
	merge_sort(b, 11);
	for (int i = 0;i < 11;i++)
		cout << b[i] << "  ";
	cout << endl;
	int c[8] = { 8,6,1,3,5,2,7,4 };
	merge_sort(c, 8);
	for (int i = 0;i < 8;i++)
		cout << c[i] << "  ";
	cout << endl;

}
Red fog
关注
专栏目录
数据结构之排序（9种）
齐梦星空
03-01 3071
概览 插入排序 直接插入排序 将数组分为两部分，前半部分有序，后半部分无序，依次从后面取数据，插入到前面指定位置。 def insertSort(nums): size = len(nums) for i in range(1, size): temp = nums[i] # 待排序的数据 count = i-1 # 代表前面有count个数据...
【基本数据类型 -- boolean】
eee3331的博客
08-25 398
Java基础 -- 基础数据类型Boolean
Lua实战之布尔值（boolean）排序
fightsyj的博客
06-21 1300
Description 将 targetTbl 按 bValue 进行排序（true > false），bValue 相同则按 id 进行顺序（有小到大）排序！ local targetTbl = { {id = 1, bValue = false}, {id = 2, bValue = true}, {id = 3, bValue = true}, {id = 4, bValue = false}, {id = 5, bValue = true} } Implemention
java list集合通过某个字段进行排序（示例：boolean类型）
情殇、小风的博客
11-14 3766
新建一个javabean public class Student { private String name; //true是正常。 false是异常 private boolean bool; private int sex; public String getName() { return name; } public...
java 根据对象的某个字段（boolean）对集合进行排序
z1193851270的博客
03-16 8010
java 根据对象的某个字段对集合进行排序 需求大概如下： 一批设备类型列表，有些是必装的，需要将必装的和不必装的进行排序。 对象的必装字段只有两个值，‘true’和‘false’，之前也针对于某个字段进行排序，但针对boolean类型进行排序，还是第一次。 JavaBean 如下: public class DG_ComponentCategory{ priva...
java 根据对象的boolean字段对集合进行排序
张俊杰 的博客
04-24 690
需求大概如下： 把boolean为true的排序到前面,false排序到后面。排序后, boolean为true的会在前面, 为false的会在后面 ,isHasMaterial 为boolean类型。
数据结构之排序及应用（实验）
12-14
数据结构之排序及应用（实验） 一、 排序算法介绍 排序算法是数据结构中非常重要的一部分，它们可以将无序的数据元素转换为有序的数据元素，从而提高数据的存储和检索效率。常见的排序算法有冒泡排序、选择排序、...
数据结构之排序算法，使用Java实现，包括冒泡排序、选择排序、插入排序、
最新发布
09-26
数据结构之排序算法，使用Java实现，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序_Data-Structure-Sort-Algorithm
c语言 数据结构 快速排序算法
04-28
c语言版本的数据结构的快速排序算法，适用于新手学习
数据结构学习笔记排序算法：基数排序
09-17
数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数排序数据结构学习笔记排序算法：基数...
学习记录521@order by的boolean排序
教练我想学编程
01-13 232
order by的boolean排序（后面接条件查询）
java8 排序boolean型和int型等
Mia的博客
01-17 3534
package com.eerdc.diy.service.impl; import com.alibaba.fastjson.JSONObject; import lombok.Data; import org.testng.collections.CollectionUtils; import java.util.ArrayList; import java.util.Comparator...
sorted排序以及字典的排序
weixin_38987362的博客
06-11 2457
seg_list = jieba.cut(s, cut_all=False) print("/".join(seg_list)) keywords = jieba.analyse.extract_tags(s,topK=100)#提取出来的关键字 col4 = ",".join(keywords)
order by的boolean排序（后面接条件查询）
weixin_34150830的博客
08-07 3716
2019独角兽企业重金招聘Python工程师标准>>> ...
【Java】list对象按某个Boolean属性排序
Mr_EvanChen的Blog
01-16 4614
对象属性如下，期望结果是：查询出来的列表，active为true的在前，false的在后。 实现如下： @Override public List<TaskNotifyPolicy> findByBelongId(String belongId) { List<TaskNotifyPolicy> taskNotifyPolicie...
java冒泡排序对布尔类型进行排序
guoyiqi
12-11 719
QQ 928900200  程序代写   java不能对布尔类型进行比较，如何冒泡排序？public static void sort(boolean[] values){ for(int m=0;m&lt;values.length-1;m++){  for(int k=0;k&lt;values.length-1;k++){   if(values[k]&amp;&amp;!values...
数据结构与排序算法详解
"该资源是一份关于数据结构中排序算法的课件，主要涵盖了内部排序的各种方法，包括插入排序、快速排序、堆排序、归并排序、基数排序，并对各种排序方法进行了综合比较。此外，还讲解了排序的定义、内部排序与外部...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值