数据结构(四) 查找 排序

七、查找

• 概述

1. 查找表：由同一类型的数据元素（或记录）构成的集合。
   
   

    
2. 
   

    
   
   
3. 
   

    
   
   

• 静态查找表

1. 静态查找是指在静态查找表上进行的查找操作，在查找表中满足条件的数据元素的存储位置或各种属性。静态查找表的查找算法主要有：                                
   
   

    
2. 顺序查找：从表的一端开始，顺序扫描线性表，依次将扫描到的关键字和给定值k进行比较，若当前扫描到的关键字与k相等，则查找成功；若扫描结束后，仍未找到关键字等于k的记录，则查找失败。                                                           
   
   

    
   
   

    
3. 折半查找：对给定值k，逐步确定待查记录所在区间，每次将搜索空间减少一半，直到查找成功或失败为止。                                                                     
   
   

    
   
   

    
   
   

    
   
   

    
4. 分块查找：                                                                                                      
   
   

    
   
   

    

• 动态查找表：表结构在查找过程中动态生成的这样一种查找表。实现动态查找方法：二叉排序树、平衡二叉树、B-树和B+树。
• 二叉排序树

1. 定义：左子树的所有结点均小于根的值；右子树的所有节点均大于根的值；它的左右子树也分别为二叉排序树。                                                                       
   
   

    
2. 二叉排序树插入新结点的过程：                                                                           
   
   

    
3. 二叉排序树插入新节点递归算法：                                                                       
   
   

    
4. 
   

    
   
   
5. 二叉排序树删除结点的算法：                                                                      
   
   

    
   
   

    
6. 二叉排序树查找算法分析：                                                                           
   
   

    

• 平衡二叉树

1. 平衡二叉树又称为AVL树，设二叉树中结点的左子树和右子树的深度分别为HL和HR。                                                                                                              
   
   

    
2. 
   

    
   
   
3. 若在构造二叉排序树的同时，使其始终保持为AVL树，则此时的二叉排序树为平衡的二叉排序树。将一棵非平衡二叉排序树调整成平衡二叉排序树的“旋转”，分为：LL平衡旋转、RR平衡旋转、LR平衡旋转、RL平衡旋转。
4. 
   

    
   
   

    
   
   

    
   
   

    
   
   

    
   
   

    
   
   

• B-树：http://haicang.blog.51cto.com/2590303/1134864 

1. B-树又称基本B树或多路平衡查找树。它是构造大型文件系统索引结构的一种数据结构类型，适合在磁盘等直接存取设备上组织动态的查找表。
2. 
   

    
   
   

    
   
   
3. 
   

    
   该公式包括没有任何关键字的叶子结点。
   
4. B-树的查找算法思路：                                                                                        
   
   

    
   
   

    
5. B-树的查找效率取决于以下两个因素：包含k的结点在B-树种所在的层数h；结点中ki的个数n。                                                                                                 
   
   

    
6. B-树的生成：                                                                                              
   
   

    
   
   

    
7. B-树的删除：                                                                                                    
   
   

    

• B+树

1. B+树是B-树的变形，目的在于有效地组织文件的索引结构。
2. m阶B+树与B-树的差异：                                                                                    
   
   

    
3. 
   

    
   
   
4. B+树种可以有两种查找方式：顺序查找——类似单链表的查找，直接在数据层进行查找。随机查找——类似B-树的查找，不同的是搜索到索引层的key与k相等时，还得继续搜索下去，直到数据层为止。
5. 
   

    
   
   

• 哈希表

1. 
   

    
   
   
2. 哈希表，根据设定的哈希函数H（key）和处理冲突的方法将一组关键字key映射到一个有限的连续的地址集上，并以关键字key在地址集中的“像”作为记录在表中的存储位置，这种表便称为哈希表，这一映射过程称为哈希造表或散列，所得存储位置称哈希地址或散列地址。                                                              
   
   

    
3. 将不同的关键码映射到同一个哈希地址上，该现象称为冲突。

• 哈希函数的构造方法

1. 常用的哈希函数构造方法有：直接定址法、除留余数法、乘余取整法、数字分析法、平方取中法、折叠法、随机数法。
2. 直接定址法：                                                                             
   
   

    
3. 除留余数法：                                                                                              
   
   

    
4. 乘余取整法：                                                                                                
   
   

    
5. 数字分析法：                                                                                           
   
   

    
6. 平方取中法：                                                                                            
   
   

    
7. 叠加法：                                                                                                             
   
   

    
       
8. 随机数法：                                                                                                    
   
   

    

• 处理冲突的方法

1. 开放定址法、链地址法、再哈希法、建立一个公共溢出区
2. 开放定址法：                                                                                          
   
   

    
   
   

    
   
   

    
3. 链地址法：                                                                                                        
   
   

    
   
   

    
4. 再哈希法：                                                                                                 
   
   

    
5. 建立一个公共溢出区：                                                                                           
   
   

    

• 红黑树

1. 红黑树，一种二叉查找树，但在每个结点上增加一个存储位表示结点颜色，可以是Red或Black。通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出两倍，因而是接近平衡的。
   
   

    
2. 红黑树虽然本质上是一棵二叉查找树，但它在二叉查找树的基础上增加了着色和相关的性质使得红黑树相对平衡，从而保证了红黑树的查找、插入、删除的时间复杂度最坏为O(log n)。红黑树和AVL树的区别在于它使用颜色来标识结点的高度，它所追求的是局部平衡而不是AVL树中的非常严格的平衡。
   
3. 红黑树的五个性质保证了红黑树的高度始终保持在logn:
   
   

    
   
   

    
4. 红黑树的旋转操作：红黑树的旋转操作和AVL树一样，分为LL、RR、LR、RL四种旋转类型，差别在于旋转完成后改变的是结点的颜色，而不是平衡因子。
5. 红黑树的插入和删除：http://blog.csdn.net/eric491179912/article/details/6179908 

---

八、排序

• 排序概述

1. 排序的分类：内部排序和外部排序（若待排序记录都在内存中，称为内部排序；若待排序记录一部分在内存，一部分在外存，则称为外部排序）。稳定排序和不稳定排序。                                                                                            
   
   

    
2. 内部排序的算法：插入排序（希尔排序）、交换排序（快速排序）、选择排序（堆排序）、归并排序、基数排序。

• 插入排序

1. 思想：每次将一个待排序的对象，按其关键码大小，插入到前面已经排好序的一组对象的适当位置上，直到对象全部插入为止。
2. 具体实现算法：直接插入排序、折半插入排序、希尔排序
3. 直接插入排序：                                                                                        
   
   

    
   
   

    
   1. void InsertSort(int a[]){
   2. int i,j;
   3. //按照有小到大的顺序排序
   4. for(i=2;i<a.length;i++){
   5. //找到无序表的第一个位置
   6. if(a[i]<a[i-1]){
   7. a[0]=a[i];
   8. //将无序表依次向后移动
   9. for(j=i-1;a[0]<a[j];j--){
   10. a[j+1]=a[j];
   11. }
   12. //将数据插入相应位置
   13. a[j+1]=a[0];
   14. }
   15. }
   16. }
   该算法的时间复杂度是：O（n2）

   
   

    
4. 折半插入排序：                                                                                           
   
   

    
   1. void BInsertSort(int a[]){
   2. int i,j,high,low;
   3. for(i=2;i<a.length;i++){
   4. a[0]=a[i];
   5. low=1;
   6. high=i-1;
   7. int min;
   8. while(low<=high){ //使用折半查找到插入的位置
   9. min=(high+low)/2;
   10. if(a[0]<a[min])
   11. high=min-1;
   12. else
   13. low=min+1;
   14. }
   15. for(j=i-1;j=>high+1;j++) //插入的位置是在high位置之后
   16. a[j+1]=a[j];
   17. a[high+1]=a[0];
   18. }
   19. }
   
   

    

   
   
5. 希尔排序：                                                                                                
   
   

    
   
   

    
                                                   从排序过程可以看出，希尔排序的一个特点是：子序列的构成不是简单地“逐段分割”，而是将相隔某个“增量”的记录组成一个子序列。
   1. void SheelSort(int a[],int dx){
   2. //这是对直接插入排序的修改
   3. //dx表示增量
   4. //当j<=0时，插入位置已经找到
   5. int i,j;
   6. for(i=dx+1;i<a.length;i++){
   7. if(a[i]<a[i-dx]){
   8. a[0]=a[i];
   9. for(j=i-dx;j>0&&a[0]<a[j];j-=dx)
   10. a[j+dx]=a[j];
   11. a[j+dx]=a[0];
   12. }
   13. }
   14. }
   
   

    

   
   

• 交换排序

1. 两两比较待排序记录的关键码，如果发生逆序（即排列顺序与排序后次序正好相反），则交换之，直到所有记录都排好序为止。
2. 冒泡排序：                                                                                                     
   1. void bubbleSort(int a[]){
   2. int i,j;
   3. for(i=1;i<a.length-1;i++){
   4. for(j=1;j<a.length-i;j++){
   5. if(a[j]>a[j+1]){
   6. a[0]=a[j];
   7. a[j]=a[j+1];
   8. a[j+1]=a[0];
   9. }
   10. }
   11. }
   12. }
   
   

    

   
   
3. 快速排序：                                                                                                  
   
   

    
   
   

    
   
   

    
   
   

    
   1. void Partition(int a[],int low,int high){
   2. //这只是一趟快速排序的算法
   3. a[0]=a[low];
   4. while(low<high){
   5. //从高位往低位扫描，找到数值小于关键字的位置，与low位置交换
   6. while(low<high&&a[0]<=a[high])
   7. high--;
   8. a[low]=a[high];
   9. //从低位往高位扫描，找到数值大于关键字的位置，与high位置交换
   10. while(low<high&&a[low]<=a[0])
   11. low++;
   12. a[high]=a[low];
   13. }
   14. //最后将关键字放入数组中
   15. a[low]=a[0];
   16. }
   快速排序平均时间复杂度和最好时间复杂度为：O（log2n），最坏时间复杂度为O（n2）。

   
   

    

• 选择排序

1. 不断从待排记录序列中选出关键字最小的记录插入已排序记录序列的后面，直到n个记录全部插入已排序记录序列中。
2. 简单选择排序：                                                                                                
   
   

    
   
   

    
   
   

    
3. 堆排序：借助于完全二叉树结构进行的排序，是一种树形选择排序。其特点是——在排序过程中，将R[1...N]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字最大（或最小）的记录。                                                                           
   
   

    
   
   

    
                            堆的根节点是堆中元素值最小（或最大）的结点，称为堆顶顶点；从根节点到每个叶节点的路径上，元素的排序序列都是递减（或递增）有序的。
   
   

    
4. 建立一个堆排序的方法：                                                                               
   
   

    
   
   

    
   
   

    
5. 堆排序的过程：                                                                                       
   
   

    
   
   

    
6. 堆排序算法实现：
   1. void HeapAdjust(int *a,int i,int size) //调整堆
   2. {
   3. int lchild=2*i; //i的左孩子节点序号
   4. int rchild=2*i+1; //i的右孩子节点序号
   5. int max=i; //临时变量
   6. if(i<=size/2) //如果i不是叶节点就不用进行调整
   7. {
   8. if(lchild<=size&&a[lchild]>a[max])
   9. {
   10. max=lchild;
   11. }
   12. if(rchild<=size&&a[rchild]>a[max])
   13. {
   14. max=rchild;
   15. }
   16. if(max!=i)
   17. {
   18. swap(a[i],a[max]);
   19. }
   20. }
   21. }
   23. void BuildHeap(int *a,int size) //建立堆
   24. {
   25. int i;
   26. for(i=size/2;i>=1;i--) //非叶节点最大序号值为size/2
   27. {
   28. HeapAdjust(a,i,size);
   29. }
   30. }
   32. void HeapSort(int *a,int size) //堆排序
   33. {
   34. int i;
   35. BuildHeap(a,size);
   36. for(i=size;i>=1;i--)
   37. {
   38. //cout<<a[1]<<" ";
   39. swap(a[1],a[i]); //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面
   40. //BuildHeap(a,i-1); //将余下元素重新建立为大顶堆
   41. HeapAdjust(a,1,i-1); //重新调整堆顶节点成为大顶堆
   42. }
   43. }
   
   

    

   
   

• 归并排序

1. “归并”的含义是将两个或两个以上的有序表合并成一个新的有序表。
2. 
   

    
   
   

    
   
   
3. 两个有序表的合并算法Merge()：                                                        
   
   

    
   
   

    
   
   

    
4. 算法分析：                                                                                                 
   
   

    

• 基数排序

1. 基数排序是一种借助多关键字排序的思想对单逻辑关键字进行排序的方法，即先将关键字分解成若干部分，然后通过对各部分关键字的分别排序，最终完成对全部记录的排序。
2. 多关键字的排序：                                                                                       
   
   

    
   
   

    
3. 链式基数排序：                                                               
   
   

    
   
   

    
   
   

    

• 排序算法总结                                                                                     
  
  

   

---

九、时间复杂度

• 
  

   
  
  

1. 该时间复杂度表达作用于递归过程。
2. n/b表示下一回递归的数据量为n/b，a表示递归的次数为a，除了递归之外的时间复杂度为O(nd)。

作者：龙猫小爷
链接：http://www.jianshu.com/p/2469a4d9708e
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。