快排(快速排序)的递归与非递归实现(文末附完整代码)

news2024/11/23 15:01:55

快排有几种不同的写法，下面一一来介绍并实现。其中又分为递归和非递归的写法，但大体思路相同，只是代码实现略有不同。(注：文章中的完整代码中，Swap()函数均省略未写，记得自己补充)

递归写法

递归的写法类似于二叉树的前序遍历，先数组本身排序，再递归左右两个区间，直至将无序数组变为有序。

hoare版本

霍尔版本是快排的提出者，也就是最开始的写法。

其基于分治的思想，在数组中选中一个值作为基准(keyi)，利用这个值(a[keyi])，进行排序，将待排序元素分为两份，比a[keyi]小的值在其左侧，比a[keyi]大的值在其右侧。此时a[keyi]这个值就排好序了，然后用递归的方法对左右两侧进行重复操作，直至无序数组变为有序。

一次排序过程如下：

其中，还有一些小问题需要注意：

代码实现为：

// 快速排序hoare版本
int PartSort(int* a, int left, int right)
{
	int keyi = left;
	int begin = left, end = right;
	while (begin < end)
	{
		//右边找小
		while (begin < end && a[end] >= a[keyi])
		{
			end--;
		}

		//左边找大
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		
		Swap(&a[begin], &a[end]);
	}

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

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int keyi = PartSort(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

挖坑法

挖坑法的思想是选中一个坑位(其值记为tmp，坑位的起始位置为begin)，然后从右边找比tmp小的值，填入其中(此时要begin++)，然后从左边找比tmp大的值填入新的坑位(此时坑位在end处，填入后要end--)。

最后begin和end相遇时，将tmp的值填入。

代码实现为：

// 挖坑法
int PartSort(int* a, int left, int right)
{
	int tmp = a[left];
	int begin = left, end = right;
	while (begin < end)
	{
		while (begin < end && a[end] >= tmp)
		{
			end--;
		}
		a[begin] = a[end];

		if (begin >= end)
		{
			break;
		}
		begin++;

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

		if (begin >= end)
		{
			break;
		}
		end--;
	}
	a[begin] = tmp;

	return begin;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int keyi = PartSort(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

写的这个版本看起来有些长，原因是我在写时，没有再用一个变量来记录坑位的位置，我们可以再添加一个变量来记录坑位的位置。

// 挖坑法
int PartSort(int* a, int left, int right)
{
	int tmp = a[left];
	int begin = left, end = right;
	int key = begin;

	while (begin < end)
	{
		while (begin < end && a[end] >= tmp)
		{
			end--;
		}

		a[key] = a[end];
		key = end;


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

		a[key] = a[begin];
		key = begin;
	}

	a[key] = tmp;
	return key;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int keyi = PartSort(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

一趟排序过程如下：

双指针

双指针法的中心思想是利用 prev 和 cur 两个指针来操作。

 具体代码实现如下：

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int keyi = left;
	int prev = left, cur = left + 1;
	while (cur <= right)
	{
		//这里如果a[keyi] > a[cur]，就会判断++prev != cur，
		//prev就会加一，只有prev和cur所在位置不同时才会发生交换。
		if (a[keyi] > a[cur] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}

	//最后交换prev位置和keyi位置的值
	Swap(&a[prev], &a[keyi]);
	keyi = prev;

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int keyi = PartSort3(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

非递归

有时候，递归深度太深会导致栈溢出，所以我们有时要用非递归来实现快排，非递归实现快排，我们就需要借助栈来实现。其思想就是模拟递归的过程，并用循环来替代，循环每走一次，就相当于递归了一次。所以要用栈来记录每次要排序的区间(也就是每次递归的 left 和 right )。栈的实现详解(点这里)。

// 快速排序hoare版本
int PartSort(int* a, int left, int right)
{
	int keyi = left;
	int begin = left, end = right;
	while (begin < end)
	{
		//右边找小
		while (begin < end && a[end] >= a[keyi])
		{
			end--;
		}

		//左边找大
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		
		Swap(&a[begin], &a[end]);
	}

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

	return keyi;
}

#include "Stacktest.h"

// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
	stack st;
	StackInit(&st);

    //先入右，再入左
	StackPush(&st, right);
	StackPush(&st, left);

	while (!StackEmpty(&st))
	{
		int begin = StackTop(&st);
		StackPop(&st);

		int end = StackTop(&st);
		StackPop(&st);

        //排序
		int keyi = PartSort(a, begin, end);

		if (keyi + 1 < end)
		{
			StackPush(&st, end);
			StackPush(&st, keyi + 1);
		}

		if (begin < keyi - 1)
		{
			StackPush(&st, keyi - 1);
			StackPush(&st, begin);
		}
	}

	StackDestory(&st);
}

具体过程如下：

优化

快排中 keyi 的选取是十分最重要的，快排的时间复杂度为O(N*logN)，但其最坏情况下为O(N^2)，如果基准值是数组中最大或最小的数值，则快速排序的递归深度会非常深，排序效率会很低。若是一个有序数组使用快速排序，则递归深度为n，单趟排序也为n，此时时间复杂度为O(N^2)，为了避免最坏情况的发生，我们通常是在数组中随意选择一个数作为基准。这里有几种方法：随机数法、取中间位置和三数取中法。

随机数法

随机选一个，有概率选到最大值或最小值。

#include<stdlib.h>
#include<time.h>

int GetNumber(int* a, int left, int right)
{
	return rand() % (right - left + 1) + left;
}

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int n = GetNumber(a, left, right);
	Swap(&a[left], &a[n]);

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

		//左边找大
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		
		Swap(&a[begin], &a[end]);
	}

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

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int keyi = PartSort1(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

int main()
{
	srand((unsigned int)time(NULL));
	int arr[] = { 6,5,7,9,2,0,3,1,8,4,10 };
	int len = sizeof(arr) / sizeof(int);
	QuickSort(arr, 0, len - 1);
    //打印数组
	Print(arr, len);
	return 0;
}

取中间位置的数

取中间元素位置，也有可能选到最大值或最小值。

​
​
#include<stdlib.h>
#include<time.h>

int GetNumber(int* a, int left, int right)
{
	return (right + left) / 2;
}

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int n = GetNumber(a, left, right);
	Swap(&a[left], &a[n]);

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

		//左边找大
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		
		Swap(&a[begin], &a[end]);
	}

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

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int keyi = PartSort1(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

int main()
{
	srand((unsigned int)time(NULL));
	int arr[] = { 6,5,7,9,2,0,3,1,8,4,10 };
	int len = sizeof(arr) / sizeof(int);
	QuickSort(arr, 0, len - 1);
    //打印数组
	Print(arr, len);
	return 0;
}

三数取中法

三数取中法是指比较最左边、最右边和中间元素的大小选出折中值。不会选到最大值或最小值。

​
​
​
#include<stdlib.h>
#include<time.h>

int GetNumber(int* a, int left, int right)
{
	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else //a[mid] <= a[left]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int n = GetNumber(a, left, right);
	Swap(&a[left], &a[n]);

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

		//左边找大
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		
		Swap(&a[begin], &a[end]);
	}

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

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	int keyi = PartSort1(a, left, right);

	QuickSort(a, left, keyi - 1);
	QuickSort(a, keyi + 1, right);
}

小区间优化

递归不断的拆分左右区间，越往深递归，所耗费的时间就越多，当递归至区间中元素个数为个位数字时，使用快排反而降低了效率，这是我们可以考虑使用插入排序来进行小区间优化。

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	//小区间优化
	if ((right - left + 1) < 10)
	{
		InsertSort(a + left, left, right);
	}

	else
	{
		int keyi = PartSort1(a, left, right);

		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}

完整代码

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

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

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

//插入排序
void InsertSort(int* a, int n)
{
	for (int i = 1; i < n - 1; i++)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

// 快速排序递归实现

int GetNumber(int* a, int left, int right)
{
	//return (right - left) / 2;

	//return rand() % (right - left + 1) + left;

	int mid = (right + left) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else //a[mid] <= a[left]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

// 快速排序hoare版本
int PartSort1(int* a, int left, int right)
{
	int n = GetNumber(a, left, right);
	Swap(&a[left], &a[n]);
	int keyi = left;
	int begin = left, end = right;
	while (begin < end)
	{
		//右边找小
		while (begin < end && a[end] >= a[keyi])
		{
			end--;
		}

		//左边找大
		while (begin < end && a[begin] <= a[keyi])
		{
			begin++;
		}
		
		Swap(&a[begin], &a[end]);
	}

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

	return keyi;
}

// 快速排序挖坑法
int PartSort2(int* a, int left, int right)
{
	int tmp = a[left];
	int begin = left, end = right;
	int key = begin;
	while (begin < end)
	{
		while (begin < end && a[end] >= tmp)
		{
			end--;
		}

		/*a[begin] = a[end];

		if (begin >= end)
		{
			break;
		}
		begin++;*/

		a[key] = a[end];
		key = end;


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

		/*a[end] = a[begin];

		if (begin >= end)
		{
			break;
		}

		end--;*/
		a[key] = a[begin];
		key = begin;
	}
	a[key] = tmp;
	return key;
}

// 快速排序前后指针法
int PartSort3(int* a, int left, int right)
{
	int keyi = left;
	int prev = left, cur = left + 1;
	while (cur <= right)
	{
		//这里如果a[keyi] > a[cur]，就会判断++prev != cur，
		//prev就会加一，只有prev和cur所在位置不同时才会发生交换。
		if (a[keyi] > a[cur] && ++prev != cur)
		{
			Swap(&a[prev], &a[cur]);
		}
		cur++;
	}

	//最后交换prev位置和keyi位置的值
	Swap(&a[prev], &a[keyi]);
	keyi = prev;

	return keyi;
}

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}

	//小区间优化
	if ((right - left + 1) < 10)
	{
		InsertSort(a + left, left, right);
	}

	else
	{
		int keyi = PartSort1(a, left, right);

		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}
}

#include "Stacktest.h"

// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
	stack st;
	StackInit(&st);

	StackPush(&st, right);
	StackPush(&st, left);

	while (!StackEmpty(&st))
	{
		int begin = StackTop(&st);
		StackPop(&st);

		int end = StackTop(&st);
		StackPop(&st);

		int keyi = PartSort1(a, begin, end);

		if (keyi + 1 < end)
		{
			StackPush(&st, end);
			StackPush(&st, keyi + 1);
		}

		if (begin < keyi - 1)
		{
			StackPush(&st, keyi - 1);
			StackPush(&st, begin);
		}
	}

	StackDestory(&st);
}

int main()
{
	srand((unsigned int)time(NULL));
	int arr[] = { 6,5,7,9,2,0,3,1,8,4,10 };
	int len = sizeof(arr) / sizeof(int);
	QuickSort(arr, 0, len - 1);
	Print(arr, len);
	return 0;
}

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

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

相关文章

[数据集][图像分类]人种黄种人白人黑人分类数据集970张4类别

[数据集][图像分类]人种黄种人白人黑人分类数据集970张4类别

数据集类型&#xff1a;图像分类用&#xff0c;不可用于目标检测无标注文件 数据集格式&#xff1a;仅仅包含jpg图片&#xff0c;每个类别文件夹下面存放着对应图片 图片数量(jpg文件个数)&#xff1a;970 分类类别数&#xff1a;4 类别名称:[“Asian”,“Caucasian”,“Indian…
阅读更多...
IDEA 连接GitHub仓库并上传项目（同时解决SSH问题）

IDEA 连接GitHub仓库并上传项目（同时解决SSH问题）

目录 1 确认自己电脑上已经安装好Git 2 添加GitHub账号 2.1 Setting -> 搜索GitHub-> ‘’ -> Log In with Token 2.2 点击Generate 去GitHub生成Token 2.3 勾选SSH后其他不变直接生成token 2.4 然后复制token添加登录账号即可 3 点击导航栏中VCS -> Create…
阅读更多...
面试官：前端实现图片懒加载怎么做？这不是撞我怀里了嘛！

面试官：前端实现图片懒加载怎么做？这不是撞我怀里了嘛！

前端懒加载&#xff08;也称为延迟加载或按需加载&#xff09;是一种网页性能优化的技术&#xff0c;主要用于在网页中延迟加载某些资源&#xff0c;如图片、视频或其他媒体文件&#xff0c;直到它们实际需要被用户查看或交互时才进行加载。这种技术特别适用于长页面或包含大量…
阅读更多...
【详细的Kylin使用心得，什么是Kylin？】

【详细的Kylin使用心得，什么是Kylin？】

&#x1f308;个人主页: 程序员不想敲代码啊 &#x1f3c6;CSDN优质创作者&#xff0c;CSDN实力新星&#xff0c;CSDN博客专家 &#x1f44d;点赞⭐评论⭐收藏 &#x1f91d;希望本文对您有所裨益&#xff0c;如有不足之处&#xff0c;欢迎在评论区提出指正&#xff0c;让我们共…
阅读更多...
手写kNN算法的实现-用欧几里德空间来度量距离

手写kNN算法的实现-用欧几里德空间来度量距离

kNN的算法思路&#xff1a;找K个离预测点最近的点&#xff0c;然后让它们进行投票决定预测点的类型。 step 1: kNN存储样本点的特征数据和标签数据step 2: 计算预测点到所有样本点的距离&#xff0c;关于这个距离&#xff0c;我们用欧几里德距离来度量&#xff08;其实还有很多…
阅读更多...
搭建自己的组件库＜2＞dialog 组件

搭建自己的组件库＜2＞dialog 组件

目录 设置title 插槽显示 控制宽高 关闭对话框 transition实现动画 引入深度选择器 同样创建组件dialogue.vue后全局注册 dialogue模版&#xff1a; <template><!-- 对话框的遮罩 --><div class"miao-dialog_wrapper"><!-- 真的对话框 …
阅读更多...
一分钟有60秒，这个有趣的原因你知道吗？

一分钟有60秒，这个有趣的原因你知道吗？

每周跟踪AI热点新闻动向和震撼发展 想要探索生成式人工智能的前沿进展吗&#xff1f;订阅我们的简报&#xff0c;深入解析最新的技术突破、实际应用案例和未来的趋势。与全球数同行一同&#xff0c;从行业内部的深度分析和实用指南中受益。不要错过这个机会&#xff0c;成为AI领…
阅读更多...
【机器学习】【遗传算法】【项目实战】药品分拣的优化策略【附Python源码】

【机器学习】【遗传算法】【项目实战】药品分拣的优化策略【附Python源码】

仅供学习、参考使用 一、遗传算法简介 遗传算法&#xff08;Genetic Algorithm, GA&#xff09;是机器学习领域中常见的一类算法&#xff0c;其基本思想可以用下述流程图简要表示&#xff1a; &#xff08;图参考论文&#xff1a;Optimization of Worker Scheduling at Logi…
阅读更多...
Linux下软件安装

Linux下软件安装

提示&#xff1a;制作不易&#xff0c;可以点个关注和收藏哦。 前言 介绍 Ubuntu 下软件安装的几种方式&#xff0c;及 apt&#xff0c;dpkg 工具的使用。 提示&#xff1a;以下是本篇文章正文内容&#xff0c;下面案例可供参考. 一、先体验一下 比如我们想安装一个软件&…
阅读更多...
DDMA信号处理以及数据处理的流程---随机目标生成

DDMA信号处理以及数据处理的流程---随机目标生成

Hello&#xff0c;大家好&#xff0c;我是Xiaojie&#xff0c;好久不见&#xff0c;欢迎大家能够和Xiaojie一起学习毫米波雷达知识&#xff0c;Xiaojie准备连载一个系列的文章—DDMA信号处理以及数据处理的流程&#xff0c;本系列文章将从目标生成、信号仿真、测距、测速、cfar…
阅读更多...
Unity Standard shader 修改（增加本地坐标裁剪）

Unity Standard shader 修改（增加本地坐标裁剪）

本想随便找一个裁剪的shader&#xff0c;可无奈的是没找到一个shader符合要求&#xff0c;美术制作的场景都是用的都标准的着色器他们不在乎你的功能逻辑需求&#xff0c;他们只关心场景的表现&#xff0c;那又找不到和unity标准着色器表现一样的shader 1.通过贴图的透明通道做…
阅读更多...
设计软件有哪些？效果工具篇（3），渲染100邀请码1a12

设计软件有哪些？效果工具篇（3），渲染100邀请码1a12

这次我们再介绍一批渲染效果和后期处理的工具。 1、ColorCorrect ColorCorrect是一种图像处理技术&#xff0c;用于调整图像的色彩和对比度&#xff0c;使其更加自然和平衡。通过ColorCorrect&#xff0c;用户可以调整图像的色调、亮度、饱和度等参数&#xff0c;以达到理想的效…
阅读更多...
网络资源模板--基于Android Studio 实现的音乐播放器

网络资源模板--基于Android Studio 实现的音乐播放器

一、项目源码获取(非开源) 关注公众号&#xff1a;《编程乐学》 后台回复&#xff1a;24060801 二、项目测试视频 网络资源模板--基于Android Studio 音乐播放器 三、项目简介 四、项目测试环境 五、项目详情设计图 1.登录注册页面介绍 <?xml version"1.0" enco…
阅读更多...
【ai】pycharm远程ssh开发

【ai】pycharm远程ssh开发

方式1： gateway的方式是远程放一个pycharm 专业版，经常下载失败 方式2： 类似vs，源码本地，同步到远程进行运行。 参考大神的分享： Pycharm远程连接服务器（2023-11-9） Pycharm远程连接服务器（windows下远程修改服务器代码）[通俗易懂] cpolar 建议同时内网穿透 选 远程开…
阅读更多...
你还在纠结U盘怎么选吗？小白带你来看

你还在纠结U盘怎么选吗？小白带你来看

前言 2024年的618活动已经开始了&#xff0c;这个活动买电子产品着实是比其他时间要便宜很多。 前几天小白的一个好朋友问我&#xff1a;U盘该怎么选&#xff1f; 呃&#xff0c;本来是想写“老朋友”的&#xff0c;结果她愣是要我改成“好朋友”。 行吧&#xff0c;那就好朋…
阅读更多...
牛客NC18 顺时针旋转矩阵【中等 数学 Java/Go/PHP/C++】

牛客NC18 顺时针旋转矩阵【中等 数学 Java/Go/PHP/C++】

题目 题目链接&#xff1a; https://www.nowcoder.com/practice/2e95333fbdd4451395066957e24909cc https://www.lintcode.com/problem/161/ 思路 Java代码 import java.util.*;public class Solution {/*** 代码中的类名、方法名、参数名已经指定&#xff0c;请勿修改&#…
阅读更多...
Transformer 动画讲解：单头注意力和多头注意力

Transformer 动画讲解：单头注意力和多头注意力

暑期实习基本结束了&#xff0c;校招即将开启。 不同以往的是&#xff0c;当前职场环境已不再是那个双向奔赴时代了。求职者在变多&#xff0c;HC 在变少&#xff0c;岗位要求还更高了。提前准备才是完全之策。 最近&#xff0c;我们又陆续整理了很多大厂的面试题&#xff0c…
阅读更多...
用 Python 撸一个 Web 服务器-第4章：动态渲染数据

用 Python 撸一个 Web 服务器-第4章：动态渲染数据

上一章中为了尽快让 Todo List 程序跑起来&#xff0c;并没有完全按照 MVC 模式编写程序。这一章就让我们一起实现一个完整的 MVC 模式 Todo List 程序首页。 使用模型操作数据 我们来分析下请求 Todo List 程序首页时&#xff0c;模型层需要做哪些事情。当一个请求到达首页视…
阅读更多...
区间预测 | Matlab实现LSTM-ABKDE长短期记忆神经网络自适应带宽核密度估计多变量回归区间预测

区间预测 | Matlab实现LSTM-ABKDE长短期记忆神经网络自适应带宽核密度估计多变量回归区间预测

区间预测 | Matlab实现LSTM-ABKDE长短期记忆神经网络自适应带宽核密度估计多变量回归区间预测 目录 区间预测 | Matlab实现LSTM-ABKDE长短期记忆神经网络自适应带宽核密度估计多变量回归区间预测效果一览基本介绍程序设计参考资料 效果一览 基本介绍 1.Matlab实现LSTM-ABKDE长…
阅读更多...
Web学习_SQL注入_联合查询注入

Web学习_SQL注入_联合查询注入

UNION 操作符用于合并两个或多个 SELECT 语句的结果集&#xff0c; UNION 结果集中的列名总是等于 UNION 中第一个 SELECT 语句 中的列名&#xff0c;并且UNION 内部的 SELECT 语句必须拥有相同数量的 列。 联合查询注入就是利用union操作符&#xff0c;将攻击者希望查询的语句…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023