学习数据结构与算法(查找—静态查找)

---

一、静态查找和动态查找的区别

1. 按查找的目的分类 可划分为 静态查找 和 动态查找 若在查找的同时对表做修改操作 则相应的表称之为动态查找表 否则称之为静态查找表
2. 静态查找表：只做查找操作的查找表。
3. 动态查找表：在查找过程同时插入查找表中不存在的数据元素，或者从 查找表中删除已经存在的某个数据元素。
4. 大白话总结：只是查找功能的就是静态查找，有查找还有插入删除等操作的是动态查找

二、静态查找分类

1.  在顺序表上面的查找（顺序查找）->顺序存储结构，链式存储结构
2.  在有序表上的查找（折半查找）->顺序存储结构
3.  在索引顺序表上的查找（分块查找） -> 顺序存储结构，链式存储结构(链式存储结构理解即可)

1. 顺序查找

顺序存储结构(按值查找 和 按位查找)

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10 
#define ElemType int
typedef struct{
	ElemType data[MaxSize];
	ElemType length;
}Sqlist;


//初始化一些数据(用来测试程序)
Sqlist * init(Sqlist *S){
	S = (Sqlist *)malloc(sizeof(Sqlist));
	if(S == NULL){
		return 0;
	}
	int i;
	for(i = 0; i < 10;i++){
		S->data[i] = i*10;
	}//0,10,20,30,40,50,60,70,80,90
	S->length = 10;
	return S;
} 


//按值查找
int findOfValue(Sqlist S,int value){
	int i;
	for(i=0;i<S.length;i++){
		if(S.data[i] == value){
			return i;
		}
	}
	return -1;
} 
//按位查找
int findOfIndex(Sqlist S,int index){
	return S.data[index-1];//因为用户不知道他的1是我们的0 
}


int main(){
	Sqlist *S = NULL;
	S = init(S);
    //int index = findValue(*S,1);
    //printf("%d\n",index);//-1
	int index = findOfValue(*S,30);//安值查找 
	printf("%d\n",index);//3
	
	int value = findOfIndex(*S,4); 
	printf("%d\n",value);//30
}

链式存储结构(按值查找)

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10 
#define ElemType int
typedef struct seqlist{
	ElemType data; 
	struct seqlist * next;
}Seqlist;


//初始化节点 
Seqlist * init(Seqlist *S){
	S = (Seqlist *)malloc(sizeof(Seqlist));
	if(S == NULL){
		return NULL;
	}
	S->data = 0;
	S->next = NULL; 
	return S;
} 


//添加结点 
int addData(Seqlist *S,int value){
	Seqlist *p = (Seqlist *)malloc(sizeof(Seqlist));
	if(p==NULL){
		return -1;		
	} 
	p->data = value;
	p->next = S->next;
	S->next = p;
	return 1;
}

//--------------这段主要代码，其他都可以不用关注-------------------
//按值查找
int findValue(Seqlist *S,int value){
	int num = 0;
	while(S->next!=NULL){
		if(S->data == value){
			return num;
		}
		num++;
		S = S->next;
	}
	return -1;
} 
//---------------------------------------------------------------- 


int main(){
	Seqlist *S = NULL;
	S = init(S);//初始化成功
	addData(S,29);//为了添加点数据测试，添加一些节点 
	addData(S,12);//为了添加点数据测试，添加一些节点 
	addData(S,32);//为了添加点数据测试，添加一些节点 
	addData(S,45);//为了添加点数据测试，添加一些节点 
	addData(S,64);//为了添加点数据测试，添加一些节点 
//	int index = findValue(S,12);//
//	printf("%d\n",index);//4
	int index = findValue(S,10);// 
	printf("%d\n",index);//-1


}

2.折半查找

顺序存储结构(按值查找)

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 10 
#define ElemType int
//折半查找法 
typedef struct{
	ElemType data[MaxSize];
	ElemType length;
}Sqlist;

//初始化数据(必须是有序数据)
Sqlist * init(Sqlist *S){
	S = (Sqlist *)malloc(sizeof(Sqlist));
	if(S == NULL){
		return NULL;
	}
	int i;
	for(i = 0; i < 10;i++){
		S->data[i] = i*10;
	}//0,10,20,30,40,50,60,70,80,90
	S->length = 10;
	return S;
} 

//按值查找
int findOfValue(Sqlist S,int value){
	int mid,low,high,i,j;
	low = 0;
	high = S.length-1;
	while(low <= high){
		mid = (low + high) / 2;
		if(S.data[mid] == value) return mid;
		else if(value > S.data[mid]){
			low = mid + 1;
		}else{
			high = mid - 1;
		}
	}
	return 0;
} 



int main(){
	Sqlist *S = NULL;
	S = init(S);
	int index = findOfValue(*S,30);//安值查找 
	printf("%d\n",index);//3


}

3.分块查找

顺序存储结构(按值查找)

性能介于顺序查找和折半查找之间（本分块查找的typedef struct indexs inx[10]没有初始化，学习思维就可以）

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

#define MaxSize 100 
#define ElemType int
//分块查找 
typedef struct{
	ElemType data[MaxSize];
	ElemType length;
}Seqlist;


struct indexs{
	ElemType key;
	ElemType index;
};
typedef struct indexs inx[10];


//初始化一些假数据 
Seqlist * init(Seqlist *S){
	S = (Seqlist *)malloc(sizeof(Seqlist));
	if(S == NULL){
		return 0;
	}
	int i;
	for(i = 0; i < 100;i++){
		S->data[i] = (i+1)*12;
	}
	S->length = 10;
	return S;
}

int findNum(inx info, int k, int bn, Seqlist S){
	//info是一个索引表
    //k是给定的特定值k
    //bn是分块的块数
    //s是一个线性表
	int low , mid ,high,finish;
	int low2,mid2,high2;
	low = 0;
	finish = 0;
	high = bn - 1;
	while(low <= high && finish ==0 ){
		mid = (low + high) / 2;
		if(k > info[mid].key){
			low = mid + 1;
		}else if(k < info[mid].key){
			high = mid - 1;
		}else{
			finish = 1;
		}
	}
	if(low < bn){
		low2 = info[low].index; 
		high2 = low + S.length/bn;
	}
	while(low2 < high2 && S.data[low2] !=k){
		low2++;
	}
	if(S.data[low2] != k){
		low2=-1;
	}
	return low2;
}


int main(){
	inx inx; //定义一个结构体数组 
	Seqlist *S = NULL;
	S = init(S);
	int index = findNum(inx,24,10,*S); 
	printf("%d\n",index);
}

链式存储结构(理解即可)