基础查找算法（二分，哈希，字典树）

最新推荐文章于 2024-08-23 16:18:28 发布

整理行囊

最新推荐文章于 2024-08-23 16:18:28 发布

阅读量544

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/qq_40132943/article/details/109240373

版权

算法专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、二分查找（最简单的查找）

1. 应用条件：

必须采用顺序存储结构。
必须按关键字大小有序排列。

2. 思想：

取中间值划分左右区间，因为元素都是有序的，取中间值划分左右区间，因此左侧都小于中间值，右侧都大于中间值
因此为了减少比较次数，每次都让关键字和中间值进行比较
相等则找到，不等则判断，小于则在左边区间，大于则在右边区间
持续划分区间，直到区间无法划分或者找到

3.步骤

准备测试数据
创建二分查找函数
1. 声明所需的变量
2. 边界判断（很重要养成习惯）
3. 初始化
4. 划分区间
  1. 确定一开始的区间【left=0，right=length-1】
  2. 取中间值：mid = left + (right - left)/2 （这么写不会超出下标，原来写法为(left + right)/2，会有溢出问题解释）
  3. 和关键字比较arr[mid] ? Key
  1. 相等则返回下标mid
  2. 小于则表示关键字在右区间(缩小区间)，left = mid + 1
  3. 大于则表示关键字在左区间(缩小区间)，right = mid - 1;
5. 重复4.2~4.3直到无法划分区间位置即[left,right],right>left；
6. 以上都执行完返回-1，表示没有查找到关键字

4. 时间空间复杂度：

时间复杂度：n,n/2,n/4,…n/2^k, n/2^k=1, ===>k = log₂n,O(log₂n);
空间复杂度：没有额外申请空间也没有递归 O(1);

5. 详细了解二分

详细解说二分

代码：

#include<stdio.h>

int BinarySearch(int *arr, int nLength, int Key);

int BinarySearch(int *arr, int nLength, int Key)
{
	//声明
	int nMid;
	int nLeft;
	int nRight;
	//边界判断
	if(arr==NULL || nLength<=0)return -1;
	//初始化
	nLeft = 0;
	nRight = nLength - 1;
	while(nLeft <= nRight)
	{
		nMid = nLeft + (nRight - nLeft)/2;
		if(Key > arr[nMid]) nLeft = nMid + 1;
		else if(Key < arr[nMid])nRight = nMid - 1;
		else return nMid;
	}
	return -1;
}


int main()
{
	int arr[] = {1,2,3,4,5,6,67,677};
	BinarySearch(arr, sizeof(arr)/sizeof(arr[0]),6);
	return 0;
}

二、哈希查找

1. 思想:

将无序的元素划分按照某一个规则，争取做到每一个元素一个位置，用空间换时间的查找

2. 步骤

一、建立哈希表：
	1. 定散列函数：散列函数：将原数组元素映射到哈希表对应位置的函数
		a. 求整取余法（留存取余法）p = key % M(M为数据的总个数)
		b. 直接地址法：直接把自身当作下标或者自身的函数关系作为下标，hash(k) = k 或 hash(k) = a · k + b
		c. 随机数法：
		d. 平法取中法：关键字平方然后取中间的几位为下标
	2. 定义解决哈希冲突的办法：
		a. 开发地址发：核心宗旨，你占我的位置我占别人的
			i. 线性探测，沿着冲突的位置+1走到没有冲突的地方
			ii. 线性补偿探测，沿着冲突位置+k个走到没有冲突的地方
			iii. 线性探测再散列：+-1，+-4，+-9，+-25等一直循环直到找到不冲突的位置即可
			iv. 随机探测
		b. 拉链法：邻接链表形式（采用头插）
二、查找
数据直接取余M，然后遍历对应指针数组的链表，直接遍历对比即可
算法实现：最简单的实现方式（散列函数采用的是求整取余法，解决哈希冲突问题采用拉链法）
步骤：
	1. 确定结构单链表
	2. 申请指针数组（原数据大小，目的是使得查找次数变小，做到每个元素一个位置）
	3. 链式加入数组，将数据添加到，数据%总个数的这个位置的链表上
search，所要搜索的数据%总个数，然后遍历链表即可。

3.哈希时间空间复杂度

时间复杂度：查找的时间复杂度为O(1)
空间复杂度：查找的空间复杂度为O(1)
哈希表创建的时间复杂度：只遍历了一次数组因此，O(n)
哈希表创建的空间复杂度：申请了总共2n个空间，没有递归，因此O(n)
注意：创建的时间空间复杂度只是针对我这个代码

4.哈希详细介绍

详细介绍哈希

代码：

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

typedef struct hash
{
	int nValue;
	struct hash *pNext;
}Hash;

void AddHash(Hash **ppHashArrayHead, int nValue);
Hash **CreateHashTable(int arr[], int nLength);
int Search(Hash **ppHashTable, int nLength, int nKey);

void AddHash(Hash **ppHashArrayHead, int nValue)
{
	Hash *pHash = (Hash *)malloc(sizeof(Hash));
	pHash->nValue = nValue;
	pHash->pNext = *ppHashArrayHead;
	*ppHashArrayHead = pHash;
}

Hash **CreateHashTable(int arr[], int nLength)
{
	Hash **ppHashArray;
	int i;
	if(arr==NULL || nLength<=0)return NULL;
	ppHashArray = (Hash **)malloc(sizeof(Hash *)*nLength);
	memset(ppHashArray, 0, sizeof(Hash *)*nLength);
	for(i=0; i<nLength; i++)
	{
		//求整取余法
		//arr[i]%nLength将数组元素添加到哈希表对应的位置上
		AddHash(&ppHashArray[arr[i]%nLength], arr[i]);
	}
	return ppHashArray;
}

int Search(Hash **ppHashTable, int nLength, int nKey)
{
	Hash *pTemp = NULL;
	if(ppHashTable==NULL)return -1;
	pTemp = ppHashTable[nKey%nLength];
	while(pTemp)
	{
		if(nKey == pTemp->nValue)
		{
			printf("%d\n", nKey);
			return 1;
		}
		pTemp = pTemp->pNext;
	}
	return -1;
}


int main()
{
	int arr[] = {1,5,7,8,9,234,234,546,547,67,876,567,567,567,324,435,456};
	Hash **ppHashTable = CreateHashTable(arr, sizeof(arr)/sizeof(arr[0]));
	Search(ppHashTable, sizeof(arr)/sizeof(arr[0]), 2);
	return 0;
}

三、字典树

1. 思想：

将字符串分解，申请一个树根，将出现的第一个字符都作为他的孩子，其他类推，从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串；每个节点的所有子节点包含的字符都不相同。

2.作用：查找和排序（狭义上字典）字符串

3.步骤：

	1. 创建字典树结构体
		a. nCount;//标记
		b. struct trie *pCharArray[26];//树的孩子
		c. str//最后得到的串
	2. 创建字典树
		a. 申请树根
		b. 按照提供的字符串数组，构造字典树
	3. 查找
		a. 查看对应的查找串的字符是否在树上出现过，即是否存在指向那个字符的位置存在。
	4. 遍历（排序的遍历）采用递归dfs遍历所有节点，把所有的标记大于0的输出
		a. for(i=0; i<26; i++)
注意：
	1. 字符树最为经典的地方是存储字符本身，而是将字符作为孩子的地址，  
而且模仿了二叉树左右孩子的结构，他直接定义了指针数组，
直接表示每个节点都有26个孩子，只要某一个孩子存在就标志着这个位置的字符出现过。
	3. 遍历树的时候记得输出在循环外去写，要不会多次输出
	4. 注意边界判断

4.时间空间复杂度：

时间复杂度： O(1)(比较字符串长度次，可查次数)
空间复杂度：O(n)（需要字符长度个空间）

5.详细了解字典树

详细介绍字典树

代码：

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

typedef struct trie
{
	int nCount;
	char *pStrTrie;
	struct trie *pCharTrieArray[26];
}Trie;

Trie *CreateSelectTrie(char **ppStrArray);
int Select(Trie *pRoot, char *pStrFind);
void Traversal(Trie *pRoot);
Trie *GetTrie();
void AddTrie(char *pStr,Trie **ppTrie);

Trie *CreateSelectTrie(char **ppStrArray, int nLength)
{
	char *pStr = NULL;
	Trie *pRoot;
	int i;
	if(ppStrArray == NULL || *ppStrArray == NULL || nLength <= 0)return NULL;
	pRoot = GetTrie();
	for(i=0; i<nLength; i++)
	{
		AddTrie(ppStrArray[i],pRoot);
	}
	return pRoot;
}

void AddTrie(char *pStr,Trie *pTrie)
{
	int i;
	if(pStr==NULL)return;
	for(i=0; i<strlen(pStr); i++)
	{
		if(pTrie->pCharTrieArray[pStr[i]%97] == NULL)
		{
			pTrie->pCharTrieArray[pStr[i]%97] = GetTrie();
		}
		pTrie = pTrie->pCharTrieArray[pStr[i]%97];
	}
	pTrie->nCount++;
	pTrie->pStrTrie = pStr;
}

Trie *GetTrie()
{
	Trie *pTrie = (Trie *)malloc(sizeof(Trie));
	memset(pTrie, 0, sizeof(Trie));
	return pTrie;
}

int Select(Trie *pRoot, char *pStrFind)
{
	int i;
	if(pRoot==NULL || pStrFind==NULL)return;
	for(i=0; i<strlen(pStrFind); i++)
	{
		if(pRoot->pCharTrieArray[pStrFind[i]%97] != NULL)
		{
			pRoot = pRoot->pCharTrieArray[pStrFind[i]%97];
		}
		else
		{
			return -1;
		}
	}
	if(pRoot->nCount > 0)
		return 1;
	else
		return -1;
}

void Traversal(Trie *pRoot)
{
	int i=0;
	if(pRoot == NULL)return;
	if(pRoot->nCount > 0)
	{
		printf("%s\n",pRoot->pStrTrie);
	}
	for(i=0; i<26; i++)
	{
		if(pRoot->pCharTrieArray[i] != NULL)
		{
			Traversal(pRoot->pCharTrieArray[i]);
		}
	}
}

int main()
{
	char *pStrArray[] = {"asdsaddsf","dsfdsf","dsfdsfsdfsd","rtynhgn"};
	Trie *pRoot = CreateSelectTrie(pStrArray, sizeof(pStrArray)/sizeof(pStrArray[0]));
	Traversal(pRoot);
	Select(pRoot, "asdsaddsf");
	return 0;
}