查找

| 这个作业属于哪个班级 | 数据结构--网络2011/2012 |
| ---- | ---- | ---- |
| 这个作业的地址 | DS博客作业05--查找 |
| 这个作业的目标 | 学习查找的相关结构 |
| 姓名 | 吕以晴 |

0.PTA得分截图

查找题目集总得分，请截图，截图中必须有自己名字。题目至少完成总题数的2/3，否则本次作业最高分5分。没有全部做完扣1分。

1.本周学习总结（0-5分）

1.1 查找的性能指标

ASL成功、不成功，比较次数，移动次数、时间复杂度


其中n为查找表中元素个数，Pi为查找第i个元素的概率，通常假设每个元素查找概率相同，Pi=1/n，Ci是找到第i个元素的比较次数。

  • ASL

    • ASL，是查找算法的查找成功时的平均查找长度的缩写，是为确定记录在查找表中的位置，需和给定值进行比较的关键字个数的期望值。
    • ASL是衡量查找算法性能好坏的重要指标。一个查找算法的ASL越大，其时间性能越差；反之，一个查找算法的ASL越小，其时间性能越好。

  • ASL成功与失败

    • 查找方式为从头扫到尾，找到待查找元素即查找成功，若到尾部没有找到，说明查找失败。

  • 顺序查找平均比较次数
    （n+1）/2

  • 顺序查找的平均移动次数

    • 插入：n/2
    • 删除：（n-1）/2

  • 时间复杂度

    • 顺序查找：
      （1）最好情况：要查找的第一个就是。时间复杂度=O(1)
      （2）最坏情况：最后一个是要查找的元素。时间复杂度=O(n)
      （3）平均情况下就是：（n+1）/2。
      所以总的来说时间复杂度为：O(n)
    • 二分查找：O(log2n)

1.2 静态查找

分析静态查找几种算法包括：顺序查找、二分查找的成功ASL和不成功ASL。

顺序查找

int SeqSearch(int s[],int n,int key)
{
    int i;
    for(i=0;s[i]!=key;i++);
    if(i<n)
        return i;
    else
        return -1;
}
  • 从表的一端开始，顺序扫描线性表，依次将扫描到的关键字与给定值k相比较。
    若扫描到的关键字=k，则查找成功；若扫描结束，仍未找到关键字=k，则查找失败。
  • Ci（第i个元素的比较次数）在于这个元素在查找表中的位置，如第0号元素就需要比较一次，第一号元素比较2次......第n号元素要比较n+1次。所以Ci=i。
1 2 3 4 5 6 7 8
  • 若查找k=3，则ASL成功=3
  • 若查找k=20，则ASL不成功=8
  • 适用情形
    • 算法简单，对查找表结构无任何要求，有序与否都行。
    • n太大时，查找效率低。

二分查找

  • ASL成功=(1*1+2*2+4*3+4*4)/11=3
  • ASL失败=（4*3+8*4）/12=3.67
  • 适用情形
    • 比较次数少，查找效率高，只用于顺序存储的有序表。
    • 不适用于经常修改操作（删除插入等）。
int Search_Bin(SSTable *ST,keyType key){
    int low=1;//初始状态 low 指针指向第一个关键字
    int high=ST->length;//high 指向最后一个关键字
    int mid;
    while (low<=high) {
        mid=(low+high)/2;//int 本身为整形，所以，mid 每次为取整的整数
        if (ST->elem[mid].key==key)//如果 mid 指向的同要查找的相等，返回 mid 所指向的位置
        {
            return mid;
        }else if(ST->elem[mid].key>key)//如果mid指向的关键字较大，则更新 high 指针的位置
        {
            high=mid-1;
        }
        //反之，则更新 low 指针的位置
        else{
            low=mid+1;
        }
    }
    return 0;
}

1.3 二叉搜索树

1.3.1 如何构建二叉搜索树（操作）

结合一组数据介绍构建过程，及二叉搜索树的ASL成功和不成功的计算方法。

构建二叉搜索树






  • ASL成功=（11+22+33+42）/8=2.75
  • ASL不成功=（21+34+4*4）/9=3.33

插入

删除

  • 假设要删的是e,此时待删元素没有左右子树，可以直接删除，将其父节点指向空

  • 假设要删的是f，此时待删除的元素只有右子树，将待删除结点的父节点指向待删除结点的右子树即可

  • 假设要删的是b，此时待删除的元素左右子树均存在，那么我们将该节点与其右子树上最小的一个节点交换，然后转为删掉最小的那一个元素c。

  • 假设要删的是c，此时待删除的元素只有左子树，我们直接将待删除节点的父节点指向待删除节点的左子树即可。

1.3.2 如何构建二叉搜索树（代码）

  • 如何构建、插入、删除及代码。
    ①插入
int BSTreeNodeInsertR(BSTreeNode **tree,DataType x) //搜索树的插入
{
    if(*tree == NULL)
    {
        *tree = BuyTreeNode(x);
        return 0;
    }

    if ((*tree)->_data > x)
        return BSTreeNodeInsertR(&(*tree)->_left,x);
    else if ((*tree)->_data < x)
        return BSTreeNodeInsertR(&(*tree)->_right,x);
    else
        return -1;
}

②删除

BSTNode* SearchNode(BSTree bt, KeyType k)//搜索树的删除
{
	if (bt == NULL || bt->key == k)
		return bt;
	else if (bt->key < k)
		return SearchNode(bt->rchild, k);
	else
		return SearchNode(bt->child, k);
}

③查找

BSTreeNode *BSTreeNodeFindR(BSTreeNode *tree,DataType x)//搜索树的查找
{
    if (!tree)
        return NULL;

    if (tree->_data > x)
        BSTreeNodeFindR(tree->_left,x);
    else if (tree->_data < x)
        BSTreeNodeFindR(tree->_right,x);
    else
        return tree;
}

  • 2.分析代码的时间复杂度
    最好：O(logn),最差：O(n)

  • 3.为什么要用递归实现插入、删除？递归优势体现在代码哪里？

    • 使用递归可以使代码更简洁清晰，可读性更好
    • 在树的遍历运算中，递归的实现明显要比循环简单得多。

1.4 AVL树

AVL树解决什么问题，其特点是什么？

  • 解决问题
    解决的是动态问题,静态的查找无需平衡树,一般排序+二分或线段树即可。
  • 特点
    它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

结合一组数组，介绍AVL树的4种调整做法。

  • LL

    • 图①结点x和结点a变换，则树平衡了。
    • x>d,d>a,所以d可作为x的左孩子。且可作为a的右孩子中的孩子
      实现：找到根结点x，与它的左孩子a进行交换就可以使二叉树树再次平衡

  • RR

    • 找到根结点x，与它的右孩子a进行交换就可以使二叉树树再次平衡

  • LR

    • 这个左右和下边的右左，略微复杂了点。须要进行两次交换。才干达到平衡，注意这时y是c的右孩子。终于y作为x的左孩子。若y是c的左孩子。终于y作为a
      的右孩子。

  • RL

    • 找到根结点x，让x的右孩子a与x的右孩子a的左孩子c进行交换，然后再让x与x此时的右孩子c进行交换。终于达到平衡；

AVL树的高度和树的总节点数n的关系？

h≈log2N(h)+1

介绍基于AVL树结构实现的STL容器map的特点、用法。

Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。map内部自建一颗红黑树（一种非严格意义上的平衡二叉树），这颗树具有对数据自动排序的功能，所以在map内部所有的数据都是有序的

 mymap.insert ( std::pair<char,int>('a',100) );
  mymap.insert ( std::pair<char,int>('z',200) );

  std::pair<std::map<char,int>::iterator,bool> ret;
  ret = mymap.insert ( std::pair<char,int>('z',500) );if(ret.second==false) {
    std::cout <<"element 'z' already existed";
    std::cout <<" with a value of "<< ret.first->second <<'\n';
  }
  • 数据的查找（包括判定这个关键字是否在map中出现）

在这里我们将体会，map在数据插入时保证有序的好处。

要判定一个数据（关键字）是否在map中出现的方法比较多，这里标题虽然是数据的查找，在这里将穿插着大量的map基本用法。

这里给出三种数据查找方法

  • 第一种：用count函数来判定关键字是否出现，其缺点是无法定位数据出现位置，由于map的特性，一对一的映射关系，就决定了count函数的返回值只有两个，要么是0，要么是1，出现的情况，当然是返回1了

  • 第二种：用find函数来定位数据出现位置，它返回的一个迭代器，当数据出现时，它返回数据所在位置的迭代器，如果map中没有要查找的数据，它返回的迭代器等于end函数返回的迭代器。

  • 数据的清空与判空

清空map中的数据可以用clear()函数，判定map中是否有数据可以用empty()函数，它返回true则说明是空map

  • 数据的删除
Map<int,string> mapStudent;
mapStudent.insert(pair<int,string>(1,“student_one”））；
mapStudent.insert(pair<int,string>(2,“student_two”））；
mapStudent.insert(pair<int,string>(3,“student_three”））；
//如果你要演示输出效果，请选择以下的一种，你看到的效果会比较好
//如果要删除1,用迭代器删除
map<int,string>::iterator iter;
iter = mapStudent.find(1);
mapStudent.erase(iter);
//如果要删除1，用关键字删除
Int n = mapStudent.erase(1);//如果删除了会返回1，否则返回0
//用迭代器，成片的删除
//一下代码把整个map清空
mapStudent.earse(mapStudent.begin(),mapStudent.end());
//成片删除要注意的是，也是STL的特性，删除区间是一个前闭后开的集合
  • 注意事项

    • List特点：元素有放入顺序，元素可重复

    • Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）

    • Map特点：元素按键值对存储，无放入顺序 (应该知道什么是键值对吧！)

    • List接口有三个实现类：LinkedList，ArrayList，Vector

    • LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢

    • ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低

    • Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet

    • SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现）

    • Query接口有一个实现类：LinkList

    • Map接口有三个实现类：HashMap，HashTable，LinkeHashMap

    • HashMap非线程安全，高效，支持null；HashTable线程安全，低效，不支持null

    • SortedMap有一个实现类：TreeMap

    • list是用来处理序列的，而set是用来处理集的。Map是知道的，存储的是键值对

    • set 一般无序不重复.map kv 结构 list 有序。

1.5 B-树和B+树

B-树和AVL树区别

AVL树结点仅能存放一个关键字，树的高度较大，而B-树的一个结点可以存放多个关键字，降低了树的高度，可以解决大数据下的查找。

B-树解决什么问题？

B-树中关键字集合分布在整颗树中，叶节点中不包含任何关键字信息，只适合随机检索

B-树定义及特点

  • 根节点至少有两个子女
  • 每个中间节点都包含k-1个元素和k个孩子，其中m/2<=k<=m
  • 每个叶子节点都包含k-1元素，其中m/2<=k<=m
  • 所有的叶子节点都位于同一层
  • 每个节点的元素从小到大排列，节点当中k-1个元素正好是k个孩子包含的元素的值域分划。

B-树的插入

插入操作是指插入一条记录，即（key, value）的键值对。如果B树中已存在需要插入的键值对，则用需要插入的value替换旧的value。若B树不存在这个key,则一定是在叶子结点中进行插入操作。

1）根据要插入的key的值，找到叶子结点并插入。

2）判断当前结点key的个数是否小于等于m-1，若满足则结束，否则进行第3步。

3）以结点中间的key为中心分裂成左右两部分，然后将这个中间的key插入到父结点中，这个key的左子树指向分裂后的左半部分，这个key的右子支指向分裂后的右半部分，然后将当前结点指向父结点，继续进行第3步。

下面以5阶B树为例，介绍B树的插入操作，在5阶B树中，结点最多有4个key,最少有2个key

a）在空树中插入39

此时根结点就一个key，此时根结点也是叶子结点

b）继续插入22，97和41

根结点此时有4个key

c）继续插入53

插入后超过了最大允许的关键字个数4，所以以key值为41为中心进行分裂，结果如下图所示，分裂后当前结点指针指向父结点，满足B树条件，插入操作结束。当阶数m为偶数时，需要分裂时就不存在排序恰好在中间的key，那么我们选择中间位置的前一个key或中间位置的后一个key为中心进行分裂即可。

d）依次插入13，21，40，同样会造成分裂，结果如下图所示。

e）依次插入30，27, 33 ；36，35，34 ；24，29，结果如下图所示。

f）插入key值为26的记录，插入后的结果如下图所示。

当前结点需要以27为中心分裂，并向父结点进位27，然后当前结点指向父结点，结果如下图所示。

进位后导致当前结点（即根结点）也需要分裂，分裂的结果如下图所示。

分裂后当前结点指向新的根，此时无需调整。

g）最后再依次插入key为17,28,29,31,32的记录，结果如下图所示。

tips:
在实现B树的代码中，为了使代码编写更加容易，我们可以将结点中存储记录的数组长度定义为m而非m-1，这样方便底层的结点由于分裂向上层插入一个记录时，上层有多余的位置存储这个记录。同时，每个结点还可以存储它的父结点的引用，这样就不必编写递归程序。

B-树删除

删除操作是指，根据key删除记录，如果B树中的记录中不存对应key的记录，则删除失败。

1）如果当前需要删除的key位于非叶子结点上，则用后继key（这里的后继key均指后继记录的意思）覆盖要删除的key，然后在后继key所在的子支中删除该后继key。此时后继key一定位于叶子结点上，这个过程和二叉搜索树删除结点的方式类似。删除这个记录后执行第2步

2）该结点key个数大于等于Math.ceil(m/2)-1，结束删除操作，否则执行第3步。

3）如果兄弟结点key个数大于Math.ceil(m/2)-1，则父结点中的key下移到该结点，兄弟结点中的一个key上移，删除操作结束。

否则，将父结点中的key下移与当前结点及它的兄弟结点中的key合并，形成一个新的结点。原父结点中的key的两个孩子指针就变成了一个孩子指针，指向这个新结点。然后当前结点的指针指向父结点，重复上第2步。

有些结点它可能即有左兄弟，又有右兄弟，那么我们任意选择一个兄弟结点进行操作即可。

下面以5阶B树为例，介绍B树的删除操作，5阶B树中，结点最多有4个key,最少有2个key

a）原始状态

b）在上面的B树中删除21，删除后结点中的关键字个数仍然大于等2，所以删除结束。

c）在上述情况下接着删除27。从上图可知27位于非叶子结点中，所以用27的后继替换它。从图中可以看出，27的后继为28，我们用28替换27，然后在28（原27）的右孩子结点中删除28。删除后的结果如下图所示。

删除后发现，当前叶子结点的记录的个数小于2，而它的兄弟结点中有3个记录（当前结点还有一个右兄弟，选择右兄弟就会出现合并结点的情况，不论选哪一个都行，只是最后B树的形态会不一样而已），我们可以从兄弟结点中借取一个key。所以父结点中的28下移，兄弟结点中的26上移,删除结束。结果如下图所示。

d）在上述情况下接着32，结果如下图。

当删除后，当前结点中只key，而兄弟结点中也仅有2个key。所以只能让父结点中的30下移和这个两个孩子结点中的key合并，成为一个新的结点，当前结点的指针指向父结点。结果如下图所示。

当前结点key的个数满足条件，故删除结束。

e）上述情况下，我们接着删除key为40的记录，删除后结果如下图所示。

同理，当前结点的记录数小于2，兄弟结点中没有多余key，所以父结点中的key下移，和兄弟（这里我们选择左兄弟，选择右兄弟也可以）结点合并，合并后的指向当前结点的指针就指向了父结点。

同理，对于当前结点而言只能继续合并了，最后结果如下所示。

合并后结点当前结点满足条件，删除结束。

B+树定义

B+树是B树的一种变形形式，B+树上的叶子结点存储关键字以及相应记录的地址，叶子结点以上各层作为索引使用。一棵m阶的B+树定义如下:
(1)每个结点至多有m个子女；
(2)除根结点外，每个结点至少有[m/2]个子女，根结点至少有两个子女；
(3)有k个子女的结点必有k个关键字。
B+树的查找与B树不同，当索引部分某个结点的关键字与所查的关键字相等时，并不停止查找，应继续沿着这个关键字左边的指针向下，一直查到该关键字所在的叶子结点为止。

B+树解决问题

同时支持随即检索与顺序检索

1.6 散列查找

哈希表的设计主要涉及哪几个内容？

  • 哈希表节点定义
template<class Value>
struct hashtable_node{
    hashtable_node *next;
    Value val;
};
  • 哈希表的定义
template<class Key, class Value>
class hashtable{
public:
	//哈希表节点键值类型
	typedef pair<Key, Value> T;

	//表节点
	typedef hashtable_node<T> node;
public:
	//构造函数
	hashtable();
	hashtable(hashtable<Key, Value> &ht)
		: buckets(ht.buckets), num_elements(ht.num_elements)
	{}

	//插入一个关键字
	void insert(T kv);   

	//根据键值删除关键字 
	void erase(Key key);

	//判断关键字是否在哈希表中
	bool find(Key key);  

	//返回哈希表中关键字个数
	int size(){
		return num_elements;
	}

	void printHashTable();
private:
	//根据传入大小判断是否需要重新分配哈希表
	void resize(int num_elements);

	//根据键值返回桶的编号
	int buckets_index(Key key, int size){
		return hash(key) % size;
	}

	//根据节点返回键值
	Key get_key(T  node){
		return node.first;
	}
private:
	//使用STL list<T>作桶
	vector<node*> buckets;    

	//哈希表中元素个数
	size_t num_elements;

	//哈希函数
	hashFunc<Key> hash;
};
  • 哈希函数的设计
/*
 * 哈希函数的设定，只考虑 4 种键值类型的哈希函数
 * char, int , double , string
 */
template<class Key> struct hashFunc{};

template<> struct hashFunc < char > {
	size_t operator()(char x) const { return x; }
};

template<> struct hashFunc < int > {
	size_t operator()(int x) const { return x; }
};

template<> struct hashFunc < double > {
	size_t operator()(const double & dValue) const
	{
		int e = 0;
		double tmp = dValue;
		if (dValue<0)
		{
			tmp = -dValue;
		}
		e = ceil(log(dValue));
		return size_t((INT64_MAX + 1.0) * tmp * exp(-e));
	}
};

template<> struct hashFunc < string > {
	size_t operator()(const string & str) const
	{
		size_t h = 0; for (size_t i = 0; i<str.length(); ++i)
		{
			h = (h << 5) - h + str[i];
		}
		return h; 
	}
};

哈希表


mod=13

  • ASL成功=（18+21+4*1）/10=1.4
  • ASL不成功=(2+1+1+9+8+7+6+5+4+3+2+1+3)/13=4.692

哈希链

  • ASL成功=（19+22）/11=1.182
  • ASL不成功=（17+22）/13=0.846

2.PTA题目介绍（0--5分）

介绍3题PTA题目

2.1 是否完全二叉搜索树（2分）

2.1.1 伪代码（贴代码，本题0分）


将数据插入空的二叉搜索树
if <树为空>
建立新的节点
并对节点赋值为num
令左右孩子均为null

else if <num大于节点数据>
插入左孩子中

else if<num小于节点数据>
插入右孩子中


层次遍历输出结果树的层序遍历结果

判断该树是否为完全二叉树
if <树为空>
不是

令p为最后入队的元素
while(p)
{
p出列
p的左右孩子入列
令p为队头元素
}
当p为空时，弹出

while 队列不为空
{
if<队头元素不为空>
{
不是
}
弹出队列
}
是
}

2.1.2 提交列表


2.1.3 本题知识点

  • 树的层次遍历
  • 队列的相关库函数，如
    ①判断队列是否为空qu.empty()
    ②返回队列中第一个元素,即最后插入到队列中的那个元素qu.front()
    ③移除队首元素qu.pop()
    ④插入一个新元素在队尾qu.push(i)
    ⑤常用的库函数还有：返回队列中元素个数qu.size();返回队列中最后一个元素，即最先入队的那个元素qu.back();插入一个新的元素在队尾qu.emplace(i);交换q1,q1两个队列的内容q1.swap(q2)

2.2 航空公司VIP客户查询（2分）

2.2.1 伪代码（贴代码，本题0分）


定义数组
输入行数n与最低里程数k

for i++:0->n
{
输入会员身份证号码a及飞行里程b
if<飞行里程小于k>
按k计算
if<身份证号码曾出现过>
叠加b
else if<未出现过>
里程直接为b
}

输入查询者个数
for i++:0->M
{
输入查询者信息
if<信息存在>
输出飞行里程数
else 
输出“No Info”
}

2.2.2 提交列表

2.2.3 本题知识点

  • 一维数组的运用：用s[i]存储会员的身份证号码信息，用a[i]存储会员的累积飞行里程数
  • for循环：通过循环来输入所需数据

2.3 基于词频的文件相似度（1分）

本题设计一个倒排索引表结构实现（参考课件）。单词作为关键字。本题可结合多个stl容器编程实现，如map容器做关键字保存。每个单词对应的文档列表可以结合vector容器、list容器实现。

2.3.1 伪代码（贴代码，本题0分）

输入文件总数N
for i++:1->N
{
while<未读到#>
for j++:0->文本长度
{
if<不是字母>
if<单词长度小于3>
不记录，重新循环
}

if<单词长度大于10>
只记录前十

else//单词长度在3到10之间
正常记录

将单词存入二维数组
单词长度归0

if<是字母>
把所有大写改为小写
}
最后一个字母需要单独判断，根据上方单词长度，以3,10为界，做不同情况讨论

输入查询个数

for i++:0->M
{
输入需查询的两文件序号
设置两个迭代器

for (同时对两个文件遍历)
it1和it2哪个字母小就让哪个向后移动
若相等，则
相同单词数++，it1,it2后移
}
输出结果

2.3.2 提交列表

2.3.3 本题知识点

  • map函数：自动建立key － value的对应，map对象是模板类，需要关键字和存储对象两个模板参数：
    std:map<int, string> personnel;
    这样就可以定义一个用int作为索引,并拥有相关联的指向string的指针.
  • 一些常见的map函数操作：

    • begin()：返回指向map头部的迭代器

    • clear(）：删除所有元素

    • count()：返回指定元素出现的次数

    • empty()：如果map为空则返回true

    • end()：返回指向map末尾的迭代器

    • equal_range()：返回特殊条目的迭代器对

    • erase()：删除一个元素

    • find()：查找一个元素

    • get_allocator()：返回map的配置器

    • insert()：插入元素

    • key_comp()：返回比较元素key的函数

    • lower_bound()：返回键值>=给定元素的第一个位置

    • max_size()：返回可以容纳的最大元素个数

    • rbegin()：返回一个指向map尾部的逆向迭代器

    • rend()：返回一个指向map头部的逆向迭代器

    • size()：返回map中元素的个数

    • swap()：交换两个map

    • upper_bound()：返回键值>给定元素的第一个位置

    • value_comp()：返回比较元素value的函数

posted @ 2021-06-14 15:09  noyiie  阅读(100)  评论(1)  编辑  收藏  举报
// 侧边栏目录 // https://blog-static.cnblogs.com/files/douzujun/marvin.nav.my1502.css