【数据结构 — 排序 — 交换排序】

news2024/11/29 0:38:11

数据结构 — 排序 — 交换排序

  • 一.交换排序
    • 1.基本思想
    • 2.冒泡排序
      • 2.1.算法讲解
      • 2.2.代码实现
        • 2.2.1.函数定义
        • 2.2.2.算法接口实现
        • 2.2.3.测试代码实现
        • 2.2.4.测试展示
    • 3.快速排序
      • 3.1.算法讲解
      • 3.2.各大算法分别单独实现
        • 3.2.1快速排序hoare版本
        • 3.2.2.快速排序hoare改进版三数取中选key法
        • 3.2.3.快速排序hoare版本改进版小区间优化法
        • 3.2.4.快速排序挖坑法
        • 3.2.5.快速排序双指针法
        • 3.2.6.快速排序非递归版
      • 3.3.算法完整源码分享
        • 3.3.1函数定义
        • 3.3.2.算法接口实现
        • 3.3.3.测试代码实现
        • 3.3.4.测试展示

一.交换排序

1.基本思想

基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

2.冒泡排序

2.1.算法讲解

以下只讲解冒泡排序代码的简单实现 ，想要更详细的了解冒泡排序的可以前往我之前的博客冒泡排序及其优化 （点击即可跳转），里面详细讲解了冒泡排序及其优化。

在这里插入图片描述

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

2.2.代码实现

2.2.1.函数定义
Sort.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
#include<time.h>


//打印
void PrintArray(int* a, int n);
//冒泡排序
void BublleSort(int* a, int n);
2.2.2.算法接口实现
Sort.c

#include"Sort.h"


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

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//冒泡排序
void BublleSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int flag = 1;
		for (int j = 0; j < n - i - 1; j++)
		{
			if (a[j + 1] < a[j])
			{
				Swap(&a[j + 1], &a[j]);
				flag = 0;
			}
		}
		if (flag == 1)
			break;
	}
}
2.2.3.测试代码实现
test.c

#include"Sort.h"


void TestBublleSort()
{
	int a[] = { 2,4,5,7,8,0,9,6,3,1 };
	printf("排序前：");
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
	printf("冒泡排序：");
	BublleSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

int main()
{
   TestBublleSort();
   
   return 0;
}
2.2.4.测试展示

在这里插入图片描述

3.快速排序

3.1.算法讲解

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可。

将区间按照基准值划分为左右两半部分的常见方式有：
1. hoare版本

在这里插入图片描述
2.hoare改进版
1. 三数取中法选key
2. 递归到小的子区间时，可以考虑使用插入排序
3.挖坑法
在这里插入图片描述
4.前后指针版本
在这里插入图片描述
5.非递归版
非递归需要借助栈来实现，将大区间划分成子区间的递归过程，需要循环实现，如果有小伙伴不懂栈的实现和使用，可以前往我之前的博客数据结构—— 栈的实现（数组栈）（点击即可跳转）了解栈的相关只是。
在这里插入图片描述

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
    在这里插入图片描述
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

3.2.各大算法分别单独实现

3.2.1快速排序hoare版本
Sort.h

//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}

		Swap(&a[left], &a[right]);
	}

	Swap(&a[left], &a[keyi]);
	keyi = left;

	QuickSortHoare(a, begin, keyi - 1);
	QuickSortHoare(a, keyi + 1, end);
}
3.2.2.快速排序hoare改进版三数取中选key法
Sort.h

//1.快速排序hoare改进版三数取中选key法
void QuickSortMid(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	if (a[begin] < a[midi])
	{
		if (a[end] > a[midi])
			return midi;
		else if (a[end] < a[midi])
			return a[begin] > a[end] ? begin : end;

	}
	else if (a[begin] > a[midi])
	{
		if (a[end] < a[midi])
			return midi;
		else if (a[end] > a[midi])
			return a[begin] < a[end] ? begin : end;
	}
	return midi;

}

//1.快速排序hoare版本改进版三数取中选key法
void QuickSortMid(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}

		Swap(&a[left], &a[right]);
	}

	Swap(&a[left], &a[keyi]);
	keyi = left;
	QuickSortMid(a,begin,keyi-1);
	QuickSortMid(a, keyi + 1, end);
}
3.2.3.快速排序hoare版本改进版小区间优化法
Sort.h

//2.快速排序hoare改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	if (a[begin] < a[midi])
	{
		if (a[end] > a[midi])
			return midi;
		else if (a[end] < a[midi])
			return a[begin] > a[end] ? begin : end;

	}
	else if (a[begin] > a[midi])
	{
		if (a[end] < a[midi])
			return midi;
		else if (a[end] > a[midi])
			return a[begin] < a[end] ? begin : end;
	}
	return midi;

}
//2.快速排序hoare版本改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	//递归到小的子区间时，可以考虑使用插入排序
	//小区间可以随意取，一般取为10
	if (end - begin + 1 <= 10)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int midi = GetMidi(a, begin, end);
		Swap(&a[midi], &a[begin]);

		int left = begin, right = end;
		int keyi = begin;

		while (left < right)
		{
			// 右边找小
			while (left < right && a[right] >= a[keyi])
			{
				--right;
			}

			// 左边找大
			while (left < right && a[left] <= a[keyi])
			{
				++left;
			}

			Swap(&a[left], &a[right]);
		}

		Swap(&a[left], &a[keyi]);
		keyi = left;

		// [begin, keyi-1] keyi [keyi+1, end]
		QuickSortSmall(a, begin, keyi - 1);
		QuickSortSmall(a, keyi + 1, end);
	}
}
3.2.4.快速排序挖坑法
Sort.h

//快速排序挖坑法
void QuickSort1(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	if (a[begin] < a[midi])
	{
		if (a[end] > a[midi])
			return midi;
		else if (a[end] < a[midi])
			return a[begin] > a[end] ? begin : end;

	}
	else if (a[begin] > a[midi])
	{
		if (a[end] < a[midi])
			return midi;
		else if (a[end] > a[midi])
			return a[begin] < a[end] ? begin : end;
	}
	return midi;

}
//挖坑法
int PartSort1(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int key = a[begin];
	int hole = begin;
	while (begin < end)
	{
		//右边找小，填到左边坑
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		a[hole] = a[end];
		hole = end;

		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		a[hole] = a[begin];
		hole = begin;
	}

	a[hole] = key;
	return hole;
}
//快速排序挖坑版
void QuickSort1(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort1(a, begin, end);
	QuickSort1(a, begin, keyi - 1);
	QuickSort1(a, keyi + 1, end);
}
3.2.5.快速排序双指针法
Sort.h

//快速排序双指针法
void QuickSort2(int* a, int begin, int end);

Sort.c

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//三数取中
int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	if (a[begin] < a[midi])
	{
		if (a[end] > a[midi])
			return midi;
		else if (a[end] < a[midi])
			return a[begin] > a[end] ? begin : end;

	}
	else if (a[begin] > a[midi])
	{
		if (a[end] < a[midi])
			return midi;
		else if (a[end] > a[midi])
			return a[begin] < a[end] ? begin : end;
	}
	return midi;

}
//双指针法
int PartSort2(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int key = begin;
	int prev = begin;
	int cur = prev + 1;

	while (cur <= end)
	{
		if (a[cur] < a[key] && ++prev != cur)
			Swap(&a[cur], &a[prev]);

		cur++;
	}
	Swap(&a[key], &a[prev]);
	key = prev;
	return key;
}
//快速排序双指针版
void QuickSort2(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort2(a, begin, end);
	QuickSort2(a, begin, keyi - 1);
	QuickSort2(a, keyi + 1, end);
}
3.2.6.快速排序非递归版
Strck.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>


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



//初始化/销毁
void STInit(ST* pst);
void STDestroy(ST* pst);

//压栈/出栈
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
//获取栈顶元素
STDataType STTop(ST* pst);

//判空
bool STEmpty(ST* pst);
//统计栈内元素个数
int STSize(ST* pst);

Strck.c

#include"Strck.h"


//初始化/销毁
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;

}

//压栈/出栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}
//获取栈顶元素
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);

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

//判空
bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;
}
//统计栈内元素个数
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

Sort.h

//快速排序非递归版
void QuickSortNonR(int* a, int begin, int end);

Sort.c

//快速排序非递归版
void QuickSortNonR(int* a, int begin, int end)
{
	ST s;
	STInit(&s);
	STPush(&s, end);
	STPush(&s, begin);

	while (!STEmpty(&s))
	{
		int left = STTop(&s);
		STPop(&s);
		int right = STTop(&s);
		STPop(&s);

		int keyi = PartSort2(a, left, right);
		//[left,keyi-1] keyi [keyi+1,right]
		if (left < keyi - 1)
		{
			STPush(&s, keyi - 1);
			STPush(&s, left);
		}

		if (keyi + 1 < right)
		{
			STPush(&s, right);
			STPush(&s, keyi + 1);
		}
	}

	STDestroy(&s);
}

3.3.算法完整源码分享

3.3.1函数定义
Strck.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>


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



//初始化/销毁
void STInit(ST* pst);
void STDestroy(ST* pst);

//压栈/出栈
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);
//获取栈顶元素
STDataType STTop(ST* pst);

//判空
bool STEmpty(ST* pst);
//统计栈内元素个数
int STSize(ST* pst);

Strck.c

#include"Strck.h"


//初始化/销毁
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = pst->capacity = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->top = pst->capacity = 0;

}

//压栈/出栈
void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->top == pst->capacity)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, sizeof(STDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		pst->a = tmp;
		pst->capacity = newcapacity;
	}

	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}
//获取栈顶元素
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);

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

//判空
bool STEmpty(ST* pst)
{
	assert(pst);

	return pst->top == 0;
}
//统计栈内元素个数
int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

Sort.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<string.h>
#include<time.h>


//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end);
//1.快速排序hoare改进版三数取中选key法
void QuickSortMid(int* a, int begin, int end);
//2.快速排序hoare改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end);
//快速排序挖坑法
void QuickSort1(int* a, int begin, int end);
//快速排序双指针法
void QuickSort2(int* a, int begin, int end);
//快速排序非递归版
void QuickSortNonR(int* a, int begin, int end);
3.3.2.算法接口实现
Sort.c

#include"Sort.h"
#include"Strck.h"

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//快速排序hoare版本
void QuickSortHoare(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}

		Swap(&a[left], &a[right]);
	}

	Swap(&a[left], &a[keyi]);
	keyi = left;

	QuickSortHoare(a, begin, keyi - 1);
	QuickSortHoare(a, keyi + 1, end);
}
//三数取中
int GetMidi(int* a, int begin, int end)
{
	int midi = (begin + end) / 2;
	if (a[begin] < a[midi])
	{
		if (a[end] > a[midi])
			return midi;
		else if (a[end] < a[midi])
			return a[begin] > a[end] ? begin : end;

	}
	else if (a[begin] > a[midi])
	{
		if (a[end] < a[midi])
			return midi;
		else if (a[end] > a[midi])
			return a[begin] < a[end] ? begin : end;
	}
	return midi;

}

//1.快速排序hoare版本改进版三数取中选key法
void QuickSortMid(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int left = begin, right = end;
	int keyi = begin;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}

		Swap(&a[left], &a[right]);
	}

	Swap(&a[left], &a[keyi]);
	keyi = left;
	QuickSortMid(a,begin,keyi-1);
	QuickSortMid(a, keyi + 1, end);
}
//2.快速排序hoare版本改进版小区间优化法
void QuickSortSmall(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	//递归到小的子区间时，可以考虑使用插入排序
	//小区间可以随意取，一般取为10
	if (end - begin + 1 <= 10)
	{
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int midi = GetMidi(a, begin, end);
		Swap(&a[midi], &a[begin]);

		int left = begin, right = end;
		int keyi = begin;

		while (left < right)
		{
			// 右边找小
			while (left < right && a[right] >= a[keyi])
			{
				--right;
			}

			// 左边找大
			while (left < right && a[left] <= a[keyi])
			{
				++left;
			}

			Swap(&a[left], &a[right]);
		}

		Swap(&a[left], &a[keyi]);
		keyi = left;

		// [begin, keyi-1] keyi [keyi+1, end]
		QuickSortSmall(a, begin, keyi - 1);
		QuickSortSmall(a, keyi + 1, end);
	}
}

//挖坑法
int PartSort1(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int key = a[begin];
	int hole = begin;
	while (begin < end)
	{
		//右边找小，填到左边坑
		while (begin < end && a[end] >= key)
		{
			end--;
		}
		a[hole] = a[end];
		hole = end;

		while (begin < end && a[begin] <= key)
		{
			begin++;
		}
		a[hole] = a[begin];
		hole = begin;
	}

	a[hole] = key;
	return hole;
}
//快速排序挖坑版
void QuickSort1(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort1(a, begin, end);
	QuickSort1(a, begin, keyi - 1);
	QuickSort1(a, keyi + 1, end);
}
//双指针法
int PartSort2(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int key = begin;
	int prev = begin;
	int cur = prev + 1;

	while (cur <= end)
	{
		if (a[cur] < a[key] && ++prev != cur)
			Swap(&a[cur], &a[prev]);

		cur++;
	}
	Swap(&a[key], &a[prev]);
	key = prev;
	return key;
}
//快速排序双指针版
void QuickSort2(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort2(a, begin, end);
	QuickSort2(a, begin, keyi - 1);
	QuickSort2(a, keyi + 1, end);
}
//快速排序非递归版
void QuickSortNonR(int* a, int begin, int end)
{
	ST s;
	STInit(&s);
	STPush(&s, end);
	STPush(&s, begin);

	while (!STEmpty(&s))
	{
		int left = STTop(&s);
		STPop(&s);
		int right = STTop(&s);
		STPop(&s);

		int keyi = PartSort2(a, left, right);
		//[left,keyi-1] keyi [keyi+1,right]
		if (left < keyi - 1)
		{
			STPush(&s, keyi - 1);
			STPush(&s, left);
		}

		if (keyi + 1 < right)
		{
			STPush(&s, right);
			STPush(&s, keyi + 1);
		}
	}

	STDestroy(&s);
}
3.3.3.测试代码实现
test.c

#include"Sort.h"

void TestQuickSortHoare()
{
	int a[] = { 2,4,5,7,8,0,9,6,3,1 };
	printf("排序前：");
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("快速排序hoaer版：");
	QuickSortHoare(a, 0,sizeof(a) / sizeof(int)-1);
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}
void TestQuickSortMid()
{
	int a[] = { 2,4,5,7,8,0,9,6,3,1 };
	printf("排序前：");
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("快速排序hoare改进版三数取中选key法：");
	QuickSortMid(a, 0, sizeof(a) / sizeof(int) - 1);
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}
void TestQuickSortSmall()
{
	int a[] = { 2,4,5,7,8,0,9,6,3,1 };
	printf("排序前：");
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("快速排序hoare改进版小区间优化法：");
	QuickSortSmall(a, 0, sizeof(a) / sizeof(int) - 1);
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}
void TestQuickSort1()
{
	int a[] = { 2,4,5,7,8,0,9,6,3,1 };
	printf("排序前：");
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("快速排序挖坑版：");
	QuickSort1(a, 0, sizeof(a) / sizeof(int) - 1);
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}
void TestQuickSort2()
{
	int a[] = { 2,4,5,7,8,0,9,6,3,1 };
	printf("排序前：");
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("快速排序双指针版：");
	QuickSort2(a, 0, sizeof(a) / sizeof(int) - 1);
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}
void TestQuickSortNonR()
{
	int a[] = { 2,4,5,7,8,0,9,6,3,1 };
	printf("排序前：");
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("快速排序非递归版：");
	QuickSortNonR(a, 0, sizeof(a) / sizeof(int) - 1);
	PrintArray(a, sizeof(a) / sizeof(int));
	printf("\n");
}

int main()
{
   TestQuickSortHoare();
   TestQuickSortMid();
   TestQuickSortSmall();
   TestQuickSort1();
   TestQuickSort2();
   TestQuickSortNonR();

   return 0;
}
3.3.4.测试展示

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1300117.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

四：爬虫-Cookie与Session实战

四：爬虫-Cookie与Session实战

四&#xff1a;Cookie与Session实战 ​ 在浏览网站的过程中&#xff0c;我们经常会遇到需要登录的情况&#xff0c;有些页面只有登录之后才可以访问。在登录之后可以连续访问很多次网站&#xff0c;但是有时候过一段时间就需要重新登录。还有一些网站&#xff0c;在打开浏览器…
阅读更多...
基于SSM框架的仓库管理系统

基于SSM框架的仓库管理系统

基于SSM框架的仓库管理系统 文章目录 基于SSM框架的仓库管理系统 一.引言二.系统设计三.技术架构四.功能实现五.界面展示六.源码获取 一.引言 现代商业环境中&#xff0c;仓库管理对于企业的运营效率和客户满意度至关重要。传统的手工管理方式已经无法满足日益复杂的仓储需求。…
阅读更多...
51系列--基于MPX4250的压力计仿真设计

51系列--基于MPX4250的压力计仿真设计

本文介绍基于MPX4250的压力计仿真设计&#xff08;完整仿真源文件及代码见文末链接&#xff09; MPX4250是一种线性度极强的一种压力传感器&#xff0c;它的线性范围为20-250kpa,测量范围也比较广泛&#xff0c;适用于大多数场合的压力检测。 仿真图如下 仿真运行视频 51系列…
阅读更多...
项目记录：SpringBoot+Vue部署在阿里云服务器

项目记录：SpringBoot+Vue部署在阿里云服务器

目录 一、服务器配置 二、后端代码打包 三、前端项目打包 四、nginx配置 一、服务器配置 部署项目需要一个服务器&#xff0c;我们可以选择阿里云的云服务器ECS&#xff0c;在实例界面可以对服务器进行管理&#xff1a; 然后需要在mobaxterm配置jdk、mysql和nginx。注意配…
阅读更多...
计算机毕业设计JAVA+SSM+springboot养老院管理系统

计算机毕业设计JAVA+SSM+springboot养老院管理系统

设计了养老院管理系统&#xff0c;该系统包括管理员&#xff0c;医护人员和老人三部分。同时还能为用户提供一个方便实用的养老院管理系统&#xff0c;管理员在使用本系统时&#xff0c;可以通过系统管理员界面管理用户的信息&#xff0c;也可以进行个人中心&#xff0c;医护等…
阅读更多...
html网页设计 03表格

html网页设计 03表格

<!DOCTYPE html> <html><head><meta charset"utf-8"><title>表格-名字</title></head><body><!-- cellspacing:单元格与单元格之间的间距 &#xff0c;默认是2个像素间距cellspadding:单元格与内容之间的间距&am…
阅读更多...
微信小程序制作-背单词的小程序制作

微信小程序制作-背单词的小程序制作

微信小程序–背单词的 好久没有发过文章了&#xff0c;但是不代表着我不去学习了喽&#xff0c;以下是我最近做的东西&#xff0c;前端的UI由朋友设计的&#xff0c;目前这个是前端使用的是微信小程序后端是Python的一个轻量型框架&#xff0c;FastApi&#xff0c;嗯&#xff…
阅读更多...
解决方案：aarch64 ARM架构下安装Miniconda + 离线迁移Conda环境的全流程 踩坑避坑指南

解决方案：aarch64 ARM架构下安装Miniconda + 离线迁移Conda环境的全流程 踩坑避坑指南

目录 一、安装Miniconda1.1、确认本机架构1.2、下载Miniconda安装包1.3、安装Miniconda 二、离线配置Conda环境2.1、查看本机配置2.2、迁移虚拟环境2.3、可能遇见的报错 最后 在ARM架构下&#xff0c;由于Anaconda并不提供官方的ARM版本&#xff0c;在很多情况下强行在ARM系统中…
阅读更多...
实战演练 | 在 Navicat 中格式化日期和时间

实战演练 | 在 Navicat 中格式化日期和时间

Navicat 支持团队收到来自用户常问的一个问题是&#xff0c;如何将网格和表单视图中的日期和时间进行格式化。其实这个很简单。今天&#xff0c;我们将介绍在 Navicat Premium 中进行全局修改日期和时间格式的步骤。 如果你想边学边用&#xff0c;欢迎点击 这里 下载免费全功能…
阅读更多...
四十三、Redis基础

四十三、Redis基础

目录 一、认识NoSql 1、定义&#xff1a; 2、常见语法 3、与关系型数据库&#xff08;SQL&#xff09;的区别&#xff1a; 二、认识Redis 1、定义&#xff1a; 2、特征&#xff1a; 3、Key的结构&#xff1a; 三、安装Redis 四、Redis常见命令 1、数据结构介绍 2、…
阅读更多...
孜然地址引导页V9(带后台)

孜然地址引导页V9(带后台)

刚刚在浏览之前经常访问的网站的时候我发现他不用那个域名了&#xff0c;然后我见这个页面好看&#xff0c;就把他干下来了&#xff0c;然后把给他写了个后台。另外如果你的子页面收录多的话&#xff0c;人家百度访问你的子页面会显示404的&#xff0c;所以为了流量可观安装这个…
阅读更多...
改进的A*算法的路径规划(1)

改进的A*算法的路径规划(1)

引言 近年来&#xff0c;随着智能时代的到来&#xff0c;路径规划技术飞快发展&#xff0c;已经形成了一套较为 成熟的理论体系。其经典规划算法包括 Dijkstra 算法、A*算法、D*算法、Field D* 算法等&#xff0c;然而传统的路径规划算法在复杂的场景的表现并不如人意&#xff…
阅读更多...
项目二 创建与操作学生管理数据库

项目二 创建与操作学生管理数据库

项目二 创建与操作学生管理数据库 #目标 创建库&#xff1b;查看库&#xff1b;操作库&#xff1b;图形工具操作库1&#xff0c;创建学生管理数据库 #创建数据库 CREATE DATABASE [IF NOT EXISTS] db_name [[DEFAULT] CHARACTER SET charset_name] [[DEFAULT] COLLATE collat…
阅读更多...
开发猿的平平淡淡周末---2023/12/10

开发猿的平平淡淡周末---2023/12/10

天气阴 温度适宜17摄氏度 AM 昨晚竟然下小雨了&#xff0c;还好还好&#xff0c;昨天刷的两个背包基本干了 一觉睡到日三竿&#xff0c;谁是神仙&#xff0c;我是神仙&#xff08;哈哈哈哈哈哈&#xff09; 刷会儿视频 补充下起床的动力 洗漱&#xff0c;恰饭&#xff0c;肝…
阅读更多...
springboot基础(80):redis geospatial的应用

springboot基础(80):redis geospatial的应用

文章目录 前言redis geospatial如何从地图上获取经纬度springboot 的相关方法调用准备redis服务器引用的依赖预设位置的keyGEOADD 添加位置GEORADIUS 获取指定经纬度附件的停车场&#xff08;deprecated&#xff09;GEORADIUS 获取指定成员附件的停车场&#xff08;deprecated&…
阅读更多...
[LeetCode]-283. 移动零-1089. 复写零

[LeetCode]-283. 移动零-1089. 复写零

目录 283. 移动零 描述 解析 代码 1089. 复写零 描述 解析 代码 283. 移动零 283. 移动零https://leetcode.cn/problems/move-zeroes/ 描述 给定一个数组 nums&#xff0c;编写一个函数将所有 0 移动到数组的末尾&#xff0c;同时保持非零元素的相对顺序。 请注意 &…
阅读更多...
【安卓12源码】WMS系列：addWindow 和 removeWindow流程

【安卓12源码】WMS系列：addWindow 和 removeWindow流程

一、Window 的属性 Window的属性定义在WindowManager的内部类LayoutParams中&#xff0c;了解Window的属性能够更好的理解WMS的内部原理。Window的属性有很多种&#xff0c;与应用开发最密切的有三种&#xff0c;它们分别是Type(Window的类型)、Flag(Window的标志)和SoftInputM…
阅读更多...
【蜗牛到家】获南明电子信息产业引导基金战略投资

【蜗牛到家】获南明电子信息产业引导基金战略投资

智慧社区生活服务平台「蜗牛到家」已于近期获得贵阳南明电子信息产业引导基金、华科明德战略投资。 贵阳南明电子信息产业引导基金属于政府旗下产业引导基金&#xff0c;贵州华科明德基金管理有限公司擅长电子信息产业、高科技产业、城市建设及民生保障领域的投资&#xff0c;双…
阅读更多...
【EI会议征稿中】第三届信号处理与通信安全国际学术会议（ICSPCS 2024）

【EI会议征稿中】第三届信号处理与通信安全国际学术会议（ICSPCS 2024）

第三届信号处理与通信安全国际学术会议&#xff08;ICSPCS 2024&#xff09; 2024 3rd International Conference on Signal Processing and Communication Security 信号处理和通信安全是现代信息技术应用的重要领域&#xff0c;近年来这两个领域的研究相互交叉促进&#xf…
阅读更多...
[每周一更]-(第76期)：Go源码阅读与分析的方式

[每周一更]-(第76期)：Go源码阅读与分析的方式

读源码可以深层理解Go的编写方式&#xff0c;理解作者们的思维方式&#xff1b;也有助于对Go语法用法深刻的理解&#xff0c;我们从这一篇说一下如何读源码&#xff0c;从哪些源码着手&#xff0c;从 简单到深入的方式学习源码&#xff1b; 学习源码也是一个修炼过程&#xff0…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023