数据结构排序、查找算法

最新推荐文章于 2024-03-03 11:20:01 发布
最新推荐文章于 2024-03-03 11:20:01 发布
阅读量635 收藏 3
点赞数 2
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43655282/article/details/103554639
版权

前言

这是数据结构的实验四的题目。
为了自己能在繁杂的文件中顺利、快速地找到自己熟悉的排序、查找算法代码，故借CSDN平台存放本人写的代码。另外，还请有缘看到此文章的同行们能多多指点。
非常感谢。

1 各种排序算法的实现

用随机函数生成16个2位正整数（10~99），实现 插入排序、 选择排序、 冒泡排序、 双向冒泡、 快速排序、 二路归并排序 等多种排序算法，输出排序中间过程、统计关键字的比较次数和记录的移动次数。

1.1 代码

代码说明：
各排序算法在同一个cpp文件中，要查看某个算法时可以把main函数中的相应排序算法的注释符号“//”去掉即可；

#include<iostream>
#include<ctime>
using namespace std;

const int maxnum = 1000; 

//数组结构
typedef struct sqlist
{
	int l[maxnum];
	int length;
}sqlist;

//------插入排序-----（采用“从后向前比较”策略）
void InsertSort(sqlist list, int length)
{
	int compare_count = 0;					//关键字比较次数
	int remove_count = 0;					//关键字移动次数
	int process = 1;						//第n次中间过程
	for (int i = 2; i <= list.length; i++) {
		compare_count++;					//关键字比较次数+1
		if (list.l[i] < list.l[i - 1]) {
			list.l[0] = list.l[i];			// list.l[0]: 人称“哨兵”
			list.l[i] = list.l[i - 1];		//将list.[i]后移
			int j = 0;
			for (j = i - 2; list.l[0] < list.l[j]; j--) {
				list.l[j + 1] = list.l[j];	//将记录逐个后移
			}			
			list.l[j + 1] = list.l[0];		//将“哨兵”插入到正确的位置
			remove_count++;					//关键字移动次数+1
		}
		//中间过程输出
		cout << "第" << process++ << "次中间过程输出:" << endl;
		for (int i = 1; i <= list.length; i++) {
			cout << list.l[i] << ' ';
		}
		cout << endl;
	}

	//输出关键字比较次数和关键字移动次数
	cout << "关键字比较次数：" << compare_count << "\t"
		<< "关键字移动次数：" << remove_count << endl;
}

//-----选择排序-----
void SelectSort(sqlist& list)
{
	int k = 0;
	int process = 1;							//第n次中间过程
	int compare_count = 0;						//关键字比较次数
	int remove_count = 0;						//关键字移动次数
	for (int i = 1; i < list.length; i++) {
		k = i;
		for (int j = i + 1; j <= list.length; j++) {
			compare_count++;					//关键字比较次数+1
			if (list.l[j] < list.l[k]) k = j;	//寻找数组剩余未排序元素中的值最小元素的下标
			if (k != i) {
				remove_count++;					//关键字移动次数+1
				int temp = list.l[i];
				list.l[i] = list.l[k];
				list.l[k] = temp;
			}
		}
		//中间过程输出
		cout << "第" << process++ << "次中间过程输出:" << endl;
		for (int i = 1; i <= list.length; i++) {
			cout << list.l[i] << ' ';
		}
		cout << endl;
	}

	//输出关键字比较次数和关键字移动次数
	cout << "关键字比较次数：" << compare_count << "\t"
		<< "关键字移动次数：" << remove_count << endl;

}

//-----冒泡排序-----
void BubbleSort(sqlist& list)
{
	int n = list.length;					//作为结束循环的条件之一
	int flag = 1;							//是否排序完成的标记
	int process = 1;						//第n次中间过程
	int compare_count = 0;					//关键字比较次数
	int remove_count = 0;					//关键字移动次数

	//设置两重循环
	while (n--&&flag) {
		flag = 0;
		for (int j = 1; j < list.length; j++) {
			compare_count++;				//关键字比较次数+1
			if (list.l[j] > list.l[j + 1]) {
				remove_count++;				//关键字移动次数+1
				flag = 1;
				int temp = list.l[j];
				list.l[j] = list.l[j + 1];
				list.l[j + 1] = temp;
			}
		}
		//中间过程输出
		cout << "第" << process++ << "次中间过程输出:" << endl;
		for (int i = 1; i <= list.length; i++) {
			cout << list.l[i] << ' ';
		}
		cout << endl;
	}

	//输出关键字比较次数和关键字移动次数
	cout << "关键字比较次数：" << compare_count << "\t"
		<< "关键字移动次数：" << remove_count << endl;
}

//-----双向冒泡----
void TwowaybubbleSort(sqlist& list)
{
	int n = list.length;
	int flag = 1;
	int process = 1;						//第n次中间过程
	int compare_count = 0;					//关键字比较次数
	int remove_count = 0;					//关键字移动次数

	int left= 1;							//初始化待排序数组的最左端元素序号
	int right= list.length;					//初始化待排序数组的最右端元素序号
	int temp_right = 0;						//暂存待更新待排序数组的最右端元素序号
	int temp_left = 0;						//暂存待更新待排序数组的最左端元素序号

	//设置两重循环
	while (n--&&flag) {
		flag = 0;
		for ( int j = left; j < right; j++) {
			compare_count++;				//关键字比较次数+1
			if (list.l[j] > list.l[j + 1]) {
				flag = 1;
				remove_count++;				//关键字移动次数+1
				int temp = list.l[j];
				list.l[j] = list.l[j + 1];
				list.l[j + 1] = temp;
				temp_right = j;
			}
		}
		right = temp_right;					//更新待排序数组的最右端元素序号
		for (int j = right; j >left; j--) {
			compare_count++;				//关键字比较次数+1
			if (list.l[j] < list.l[j-1]) {
				flag = 1;
				remove_count++;				//关键字移动次数+1
				int temp = list.l[j];
				list.l[j] = list.l[j - 1];
				list.l[j - 1] = temp;
				temp_left = j;
			}
		}
		left = temp_left;					//更新待排序数组的最左端元素序号
		//中间过程输出
		cout << "第" << process++ << "次中间过程输出:" << endl;
		for (int i = 1; i <= list.length; i++) {
			cout << list.l[i] << ' ';
		}
		cout << endl;
		cout << "left,right：" << left << ' ' << right << endl;
	}

	//输出关键字比较次数和关键字移动次数
	cout << "关键字比较次数：" << compare_count << "\t"
		<< "关键字移动次数：" << remove_count << endl;
}

//-----快速排序-----
int QSort_process = 1;						//第n次中间过程
int QSort_compare_count = 0;				//关键字比较次数
int QSort_remove_count = 0;					//关键字移动次数
void QSort(sqlist& list,int low, int high)
{
	int i, j, pivotkey;
	i = low;
	j = high;
	if (low < high){
		pivotkey = list.l[low];				 //设置枢轴
		while (i != j){
			while (j > i&& list.l[j] >= pivotkey){
				--j;
				QSort_compare_count++;	 //关键字比较次数+1
			}
			if (i < j){
				list.l[i] = list.l[j];	 //交换
				++i;
				QSort_remove_count++;	 //关键字移动次数+1
			}

			while (i < j && list.l[i] <= pivotkey){
				++i;
				QSort_compare_count++;	 //关键字比较次数+1
			}
			if (i < j){
				list.l[j] = list.l[i];	 //交换
				--j;
				QSort_remove_count++;	 //关键字移动次数+1
			}
		}
		list.l[i] = pivotkey;				 //枢轴记录到位
		//中间过程输出
		cout << "第" << QSort_process++ << "次中间过程输出:" << endl;
		for (int n = 1; n <= list.length; n++) {
			cout << list.l[n] << ' ';
		}
		cout << endl;

		//递归
		QSort(list, low, i - 1);
		QSort(list, i + 1, high);
	}
}

//-----二路归并排序-----
int MSort_process = 1;						//第n次中间过程
int MSort_compare_count = 0;				//关键字比较次数
int MSort_remove_count = 0;					//关键字移动次数
void Merge(sqlist &list, int low, int mid, int high)
{
	int len = high - low + 1;
	int* temp = new int[len];
	int i = low; int j = mid + 1;			 //i,j分别为两个子序列的下标
	int k = 0;								 //新合并的数组的下标
		while (i <= mid && j <= high) {
			if (list.l[i] <= list.l[j]) {
				MSort_compare_count++;		 //关键字比较次数+1
				MSort_remove_count++;		 //关键字移动次数+1
				temp[k] = list.l[i];
				i++;
				k++;
			}
			else {
				MSort_compare_count++;		 //关键字比较次数+1
				MSort_remove_count++;		 //关键字移动次数+1
				temp[k] = list.l[j];
				j++;
				k++;
			}
		}
		while (i <= mid) {
			temp[k] = list.l[i];
			i++;
			k++;
		}
		while (j <= high) {
			temp[k] = list.l[j];
			j++;
			k++;
		}
	for (int i = 0; i < len; i++) {
		list.l[low+i] = temp[i];
	}
}

void MSort(sqlist &list,int low,int high)
{
	if (low < high) {
		int mid = (low + high) / 2;
		//递归
		MSort(list, low, mid);
		MSort(list, mid + 1, high);
		//合并左右序列（子树）
		Merge(list, low, mid, high);
	}
	//中间过程输出
	cout << "第" << MSort_process++ << "次中间过程输出:" << endl;
	for (int n = 1; n <= list.length; n++) {
		cout << list.l[n] << ' ';
	}
	cout << endl;
}


int main()
{
	/*
	-----------------------------------------
		说明：
			随机生成数组首元素下标为 1
	-----------------------------------------
	*/

	// 生成随机数组
	srand(unsigned(time));
	sqlist list;
	list.length = 0;
	cout << "请输入生成数组的长度：";
	cin >> list.length;						//输入数组的长度
	cout << "生成的数组为：";
	for (int i = 1; i <=list.length; i++){  
		list.l[i] =(int) rand() % 90 + 10;
		cout << list.l[i]<<' ';
	}
	cout << endl;

	//-----插入排序-----
	//InsertSort(list,list.length);

	//-----选择排序-----
	//SelectSort(list);

	//-----冒泡排序-----
	//BubbleSort(list);

	//-----双向冒泡-----
	//TwowaybubbleSort(list);

	//-----快速排序-----
	//QSort(list, 1, list.length);
	  //输出关键字比较次数和关键字移动次数
	//cout << "关键字比较次数：" << QSort_compare_count << "\t"
	//	<< "关键字移动次数：" << QSort_remove_count << endl;
	
	//-----归并排序-----
	//MSort(list, 1, list.length);
	  //输出关键字比较次数和关键字移动次数
	//cout << "关键字比较次数：" << MSort_compare_count << "\t"
		//<< "关键字移动次数：" << MSort_remove_count << endl;
}

1.2 运行结果

  • 插入排序
    在这里插入图片描述
  • 选择排序
    在这里插入图片描述
  • 冒泡排序
    在这里插入图片描述
  • 双向冒泡排序
    在这里插入图片描述
  • 快速排序
    在这里插入图片描述
  • 归并排序

在这里插入图片描述
在这里插入图片描述

2 各种查找算法的实现

2.1 顺序查找

使用数组或链表结构。用随机函数生成16个不重复的字母（’a’~’z’），键盘输入待查找的字母，返回查找成功与否，若成功则返回该字母所在的位置（序号），并计算比较次数。

2.1.1 代码
#include<iostream>
#include<ctime>
using namespace std;

//-----顺序查找-----
void Search_Seq(char* s)
{
	cout << "请输入想寻找的字母：";
	char x;
	cin >> x;								//输入想找的字母
	int index = 0;
	int count = 0;							//比较次数,初始化为0
	while (s[index] != '\0') {
		++count;
		if (s[index++] == x) {
			cout << "已找到字母 " << x << " ,它的下标为：" << index - 1 << endl;
			break;
		}
	}
	if (count == 17) {

		cout << "没有找到该字母,共比较了：" << count-1 << " 次"<< endl;
	}
	else cout << "共比较了：" << count << " 次";
}

int main()
{
	/*
	-----------------------------------------
		说明：
			随机生成数组首元素下标为 0
	-----------------------------------------
	*/

	// 生成随机数组
	srand(unsigned(time));
	char* s=new char[17];					//字符数组
	for (int i = 0; i < 16; i++) s[i] = '\0';
	cout << "生成的数组为：";
	int k = 0;
	while (k != 16) {
		int flag = 0;						//用于检测是否有相同的字母出现
		s[k] = 'a' + (rand() % 26);
		for (int i = 0; i < 16; i++) {
			if (k != i) {
				if (s[k] == s[i]) flag = 1;	//若flag=1，则重新加入一个字母
			}
		}
		if (flag == 0) ++k;					//若flag=0，往数组下一个位置添加字母
	}
	for (int i = 0; i < 16; i++) 
		cout << s[i] << " ";				//打印随机生成的字符数组
	s[16] = '\0';							//字符串的最后一位是'\0'
	cout << endl;

	//-----顺序查找-----
	Search_Seq(s);
}
2.1.2 运行结果
  • 查找成功
    在这里插入图片描述
  • 查找失败
    在这里插入图片描述

2.2 折半查找

用数组实现，查找前元素先排序。计算比较次数。分别用查找成功、不成功进行测试。

2.2.1 代码
#include<iostream>
#include<ctime>
using namespace std;

//-----顺序查找-----

void TwowaybubbleSort(char* s)
{
	int n = 16;
	int flag = 1;							//检测是否已排序完成

	int left = 1;							//初始化待排序数组的最左端元素序号
	int right = 15;							//初始化待排序数组的最右端元素序号
	int temp_right = 0;						//暂存待更新待排序数组的最右端元素序号
	int temp_left = 0;						//暂存待更新待排序数组的最左端元素序号

	//设置两重循环
	while (n-- && flag) {
		flag = 0;							
		for (int j = left; j < right; j++) {
			if (s[j] > s[j + 1]) {
				flag = 1;
				int temp = s[j];
				s[j] =s[j + 1];
				s[j + 1] = temp;
				temp_right = j;
			}
		}
		right = temp_right;					//更新待排序数组的最右端元素序号
		for (int j = right; j > left; j--) {
			if (s[j] < s[j - 1]) {
				flag = 1;
				int temp = s[j];
				s[j] = s[j - 1];
				s[j - 1] = temp;
				temp_left = j;
			}
		}
	}
}
void Search_Bin(char* s)
{
	TwowaybubbleSort(s);					//先使用双向冒泡进行排序
	int compare_count = 0;					//记录比较次数
	cout << "请输入想寻找的字母：";
	char x;
	cin >> x;								//输入待寻找的字母
	
	int low = 0; int high = 15;
	int mid = 0;
	while (low <= high) {
		mid = (low + high) / 2;
		if (x == s[mid]) {
			compare_count++;
			cout << "已找到字母 " << x << endl;
			break;
		}
		else if (x < s[mid]) {
			compare_count++;
			high = mid - 1;
		}
		else {
			compare_count++;
			low = mid + 1;
		}
	}
	if(low>high&&x!=s[low]) cout<< "未找到该字母，总共比较了 " << compare_count << " 次" << endl;
	else cout << "总共比较了 " << compare_count << " 次" << endl;
}
	

int main()
{
	/*
	-----------------------------------------
		说明：
			随机生成数组首元素下标为 0
	-----------------------------------------
	*/

	// 生成随机数组
	srand(unsigned(time));
	char* s = new char[17];					//字符数组
	for (int i = 0; i < 16; i++) s[i] = '\0';
	cout << "生成的数组为：";
	int k = 0;
	while (k != 16) {
		int flag = 0;						//用于检测是否有相同的字母出现
		s[k] = 'a' + (rand() % 26);
		for (int i = 0; i < 16; i++) {
			if (k != i) {
				if (s[k] == s[i]) flag = 1;	//若flag=1，则重新加入一个字母
			}
		}
		if (flag == 0) ++k;					//若flag=0，往数组下一个位置添加字母
	}
	for (int i = 0; i < 16; i++)
		cout << s[i] << " ";				//打印随机生成的字符数组
	s[17] = '\0';							//字符串的最后一位是'\0'
	cout << endl;

	//-----折半查找-----
	Search_Bin(s);	
}
2.2.2 运行结果
  • 查找成功
    在这里插入图片描述
  • 查找失败
    在这里插入图片描述

2.3 二叉查找树

手工输入10个字母，生成一棵二叉查找树，用递归算法打印树结构或分别输出先序和中序遍历序列以确认其结构。键盘输入待查找的字母，计算比较次数。分别用查找成功、不成功进行测试.

2.3.1 代码
#include<iostream>
using namespace std;

//二叉查找树结构
typedef struct BSTNode
{
	char data;
	BSTNode* lchild, * rchild;
}BSTNode,*BSTree;

//二叉排序树的插入
void InsertBST(BSTree& T, char x)
{
	if (!T) {
		BSTNode* new_tree = new BSTNode;		//生成新结点
		new_tree->data = x;
		new_tree->lchild = new_tree->rchild = NULL;
		T = new_tree;
	}
	else if (x < T->data) InsertBST(T->lchild, x);
	else if (x > T->data) InsertBST(T->rchild, x);
}
//二叉排序树的创建
void CreatBST(BSTree& T)
{
	T = NULL;
	char x;
	cin >> x;
	int i = 0;				//用于提示已经输入了多少个字母
	while (x != '#') {
		InsertBST(T, x);
		cout << "这是输入的第 " << ++i << " 个字母" << endl;
		cin >> x;
	}
}
//二叉树的先序遍历
void Preorder(BSTree T)//前序遍历（递归实现）
{
	if (T != NULL)
	{
		cout << T->data << " ";
		Preorder(T->lchild);
		Preorder(T->rchild);
	}
}
//二叉树的中序遍历
void Mreorder(BSTree T)//前序遍历（递归实现）
{
	if (T != NULL)
	{
		Mreorder(T->lchild);
		cout << T->data << " ";
		Mreorder(T->rchild);
	}
}

//-----二叉查找树-----
int compare_count = 0;				//全局变量。记录比较次数
BSTree SearchBST(BSTree T, char x)
{
	compare_count++;
	if (!T|| x == T->data) {
		if (!T)
			cout << "查询失败,共查找了 " << compare_count << " 次\n";
		else
			cout << "已找到字母 " << T->data << " ,共查找了 " << compare_count << " 次\n";
		return T;
	}
	else if (x < T->data) return SearchBST(T->lchild, x);
	else if (x >= T->data) return SearchBST(T->rchild, x);
}

int main()
{
	//创建二叉查找树
	BSTree T = new BSTNode;
	cout << "请输入十个字母(输入#结束): " << endl;
	CreatBST(T);						
	cout<<"输入完成\n";

	//中序遍历二叉查找树
	cout << "\n先序遍历输出：";
	Preorder(T);

	//中序遍历二叉查找树
	cout << "\n中序遍历输出(按照各字母的ASCⅡ码大小)："; 
	Mreorder(T);

	//输入待查找字母
	cout << "\n请输入想查询的字母(如果想退出查找，请输入$) ";
	char letter;
	cin >> letter;						

	//查找字母
	while (1 && letter != '$') {
		SearchBST(T, letter);
		cout << "\n请输入想查询的字母(如果想退出查找，请输入$) ";
		cin >> letter;
	}
}
2.3.2 运行结果

查找成功和失败都在同一张截图里了。
在这里插入图片描述

猫咪钓鱼
关注
  • 2
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
内部排序算法的比较已知技术参数和设计
12-20
通过随机数据比较各内部排序算法的关键字比较次数和关键字移动的次数，以取得直观感受。待排序表的表长不小于100；至少要用5组不同的输入数据作比较；排序算法不少于5种； 待排序的元素的关键字为整数； 比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换以3次计)。演示程序以人机对话的形式进行。每次测试完毕显示各种比较指标的列表，以便比较各种排序的优劣。 最后要对结果作简单的分析。
数据结构与算法--查找与排序（一）
opera95的博客
04-22 1万+
Top 线性查找二分查找冒泡排序插入排序选择排序快速排序归并排序 1 线性查找 1.1 问题 线性查找，又称为顺序查找，是指在所有给定的值中从一端开始逐个检查每个元素是否为要查找的对象，直到找到为止的过程。 1.2 步骤 实现此案例需要按照如下步骤进行。 步骤一：逐个查找要查找的对象 代码如下： #include stdio.h>typ
常用的算法和数据结构分析（查找和排序）
袁裕飞的专栏
02-14 2384
 查找（1）       线性表查找     顺序查找：        顺序查找效率很低，但对于待查的结构没有任何要求，而且算法非常简单，当待查表中的记录个数较少时，采用顺序查找较好。      折半查找：        折半查找的平均查找长度小，查找速度快，但是它要求表中的记录是有序的，且只能用于顺序存储结构。对于不常变动的有序表，采用折半查找时较理想的。  
数据结构查找排序算法总结分析
Super_Demo的专栏
11-22 2244
一、查找 1、静态查找 1）顺序查找 2）折半查找（二分查找） 3）索引查找（分块查找） 2、动态查找 1）二叉排序树 2）平衡二叉排序树 3）B_树B+树 3、哈希表查找
排序、查找（数据结构）
mrhjlong
04-19 2817
一、排序算法 1、冒泡排序 思路：按照约定的排序顺序，两两比较相邻的数据，如果反序则交换，直到没有反序的记录为止。 算法复杂度：O(n^2) 比较次数：(1 + 2 + 3 +…+ n-1) = n * (n – 1) / 2 次 /************************************************************************* ...
数据结构排序算法C语言实现
11-26
包括插入排序、堆排序、归并排序、基数排序、快速排序、冒泡排序、桶排序、拓扑排序、希尔排序、选择排序。
数据结构排序查找常用算法实现.zip
08-16
主要包含冒泡 插入 选择 希尔 快速排序 堆排序 折半查找等常用的数据结构排序算法的实现
数据结构值排序算法.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
数据结构相关查找算法
09-27
查找算法（包含二叉排序，哈希表，顺序查找，二分查找，B树查找，分块查找，折半查找）用于数据结构学习的
数据结构和算法PDF文档
06-02
1000多页的算法题解，包含数据结构，排序，查找，递归，回溯算法，二叉树，动态规划，贪心算法，双指针，滑动窗口，前缀和等。
数据结构 查找和排序算法
最新发布
m0_45236411的博客
03-03 980
直接插入排序每一趟都有重新遍历一遍前面的节点，并且前面的算子是有序的，这样就可以用折半插入排序，这样在一定条件下时间可以减半，待确定插入位置之后，再统一的向后移动元素。堆排序的思路很简单，首先将存放在数组中的元素组成一个初始堆，堆顶的元素就是最大值或者最小值，取出堆顶元素之后将堆底元素放入堆顶，再进行堆排序。插入排序是一种简单直观的排序算法，其基本思想是将一个待排序的记录按其关键字大小插入前面已经排好序的子序列，直到全部记录插入完成。，它吸取了顺序查找和折半查找各自的优点，既有动态结构，又适用于快速查找。
数据结构之算法排序与查询
DemoWaterGhost的博客
01-22 530
当我们面临一堆数据时，我们就会想到如何对数据进行规范化的处理。首先肯定要将数据进行排序，一堆杂乱无章的数据肯定是不利于进行数据操作的，那么只有将数据进行科学、适当地进行排序，才能使数据在后续操作中更加快捷、方便和高效。 PS：本主题报告只在于告诉小白如何懂得算法排序与查询的简单原理，对于具体实现不加以过多的赘述。 接下来我将简单介绍八大排序算法 1.插入排序：简单插入排序、希尔排序 2.交换排序：冒泡排序、快速排序 3.选择排序：简单选择排序、堆排序 4.归并排序 5.基数排序 一、
数据结构-实验五  查找算法
热门推荐
brandong
09-26 1万+
广州大学学生实验报告   开课实验室：计算机科学与工程实验（电子楼417）     2018年06月13日 学院 计算机科学与教育软件学院 年级、专业、班 网络161 姓名 卟咚君 学号 1606100*** 实...
[Data Structure & Algorithm] 七大查找算法
weixin_34128839的博客
08-09 3218
　　查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找。本文简单概括性的介绍了常见的七种查找算法，说是七种，其实二分查找、插值查找以及斐波那契查找都可以归为一类——插值查找。插值查找和斐波那契查找是在二分查找的基础上的优化查找算法。树表查找和哈希查找会在后续的博文中进行详细介绍。 　　查找定义：根据给定的某个值，在查找表中确定一个其关键字...
面试必问排序算法汇总—JAVA实现
wmingstar
04-15 174
排序算法 排序算法是程序员面试时被问的频率较高的算法，同时也是很多复杂算法题的常用工具算法，所以熟练掌握常用的几种排序算法是十分必要的，鉴于网络上已经有大神做了很好的总结，此处我借花献佛，在此做个汇总。 郭耀华’s Blog 作者对排序算法做了非常深刻细致的总结，为方便大家更直观的理解，每个算法还配有动态图，非常棒，推荐： https://www.cnblogs.com/guoyaohua/p/8...
十大排序算法和常见的查找算法——python实现
Z__legend的博客
05-25 581
文章目录时间复杂度排序算法交换排序冒泡排序快速排序（使用了分治策略和递归）插入排序直接插入排序希尔排序选择排序简单选择排序堆排序（未实现）归并排序非比较类排序查找算法顺序查找二分查找插值查找未实现的查找算法 时间复杂度 O© 常量时间复杂度 - 布隆过滤器 / 哈希存储 O(log2n) 对数时间复杂度 - 折半查找（二分查找） O(n) 线性时间复杂度 - 顺序查找 / 计数排序 O(n*log2n) 对数线性时间复杂度 - 高级排序算法（归并排序、快速排序） O(n2) 平方时间复杂度 - 简单排序算
数据结构与算法-排序和查找算法
weixin_50443430的博客
10-21 594
排序也称之为排序算法（Sort Algorithm）,是讲一组数据以指定的顺序进行排列的过程。 排序分类 算法时间效率 基数排序 基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序作用， 基数排序法是属于稳定性的排序。 讲所有的待比较数值统一设置为同样的数位长度，位数比较短的数前面补零，然后..
基本的排序和查找算法
a984145377的博客
06-26 435
排序算法 一、冒泡算法：优点没啥，缺点就是数据量多时候速度很慢，平均时间复杂度为n平方，稳定，依赖内存。 for(let i = 0;i<arr.length;i++){ for(var j = i+1;j<arr.length-1;j++){ if(arr[i]>arr[j]){ let temp = arr[j]; arr[j] =...
数据结构排序与折半查找算法说明
06-03
排序是将一组无序的数据按照一定的规则进行排列的过程。常见的排序算法有冒泡排序、插入排序、选择排序、快速排序、归并排序等。...如果需要进行动态查找，需要使用其他数据结构，如二叉查找树、红黑树等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

猫咪钓鱼

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值