顺序表查找和有序表查找

查找里面顺比表查找和有序表查找(包括二分查找,插值查找,斐波那契查找)比较简单,直接贴代码,代码里面有详细注释。

  1 #include <iostream>
  2 using namespace std;
  3
  4 //顺序表查找(线性查找、静态表查找)  时间复杂度为O(n)
  5 int Seq_Search(int *s,int n,int key)
  6 {
  7     s[0] = key;   //设置了一个哨兵,避免了每次比较一次过后都要判断查找位置是否越界
  8     int i = n;
  9     while (s[i] != key)
 10     {
 11         --i;
 12     }
 13     return i;
 14 }
 15
 16 //二分查找(折半查找) 前提条件:记录的关键码必须有序,必须是顺序存储   时间复杂度为O(logn)
 17 int Binary_Search(int *s,int n,int key)
 18 {
 19     int low,mid,high;
 20     low = 1;
 21     high = n;
 22     while (low <= high)
 23     {
 24         mid = (low + high)/2;
 25         if (s[mid] > key)
 26         {
 27             high = mid - 1;
 28         }else if (s[mid] < key)
 29         {
 30             low = mid + 1;
 31         }else
 32             return mid;
 33     }
 34     return 0;
 35 }
 36
 37 //插值查找(对于表长较大,关键字分布比较均匀的查找表来说,插值查找算法的平均性能要比二分查找算法的性能高)
 38 int B_Search(int *s,int n,int key)
 39 {
 40     int low,mid,high;
 41     low = 1;
 42     high = n;
 43     while (low <= high)
 44     {
 45         mid = low + (high - low)*(key - s[low])/(s[high] - s[low]);
 46         if (s[mid] > key)
 47         {
 48             high = mid - 1;
 49         }else if (s[mid] < key)
 50         {
 51             low = mid + 1;
 52         }else
 53             return mid;
 54     }
 55     return 0;
 56 }
 57
 58 //计算斐波那契数列
 59 void Fibonacci(int *F)
 60 {
 61     F[0]=0;
 62     F[1]=1;
 63     for(int i =2;i<10;i++)
 64     {
 65         F[i] = F[i-1] + F[i-2];
 66     }
 67 }
 68
 69 //斐波那契查找(时间复杂度是O(logn))
 70 int Fibonacci_Search(int *s,int n,int key,int *F)
 71 {
 72     int low,high,mid,i,k;
 73     low = 1;
 74     high = n;
 75     k = 0;  //k为斐波那契数列的下标
 76     while (n > F[k] - 1)  //计算n位于斐波那契数列的位置
 77     {
 78         k++;
 79     }
 80     for (i = n;i < F[k] -1;i++)  //将不满的数值补全
 81     {
 82         s[i] = s[n];
 83     }
 84     //开始查找
 85     while (low <= high)
 86     {
 87         mid = low + F[k] - 1;
 88         if (key < s[mid])
 89         {
 90             high = mid - 1;
 91             k = k - 1;   //斐波那契数列下标减一位
 92         }else if (key > s[mid])
 93         {
 94             low = mid + 1;
 95             k = k - 2;   //斐波那契数列下标减两位
 96         }else
 97         {
 98             if (mid <= n)
 99             {
100                 return mid;
101             }else
102                 return n;   //若mid>n,说明是补全的数值,返回n
103         }
104     }
105     return 0;
106 }
107
108 void main()
109 {
110     int s[] = {0,1,16,24,35,47,59,62,73,88,99};
111     int n = 11;
112     int m,a;
113     int Fbi[10];
114     Fibonacci(Fbi);
115
116     cout << "输入顺序表查找要查找的数字: ";
117     cin >> m;
118     a = Seq_Search(s,n,m);
119     cout << "顺序表查找" << m <<"的位置在:"<< a << endl << endl;
120
121     cout << "输入二分查找要查找的数字: ";
122     cin >> m;
123     a = Binary_Search(s,n,m);
124     cout << "二分查找" << m <<"的位置在:"<< a << endl << endl;
125
126     cout << "输入插值查找要查找的数字: ";
127     cin >> m;
128     a = B_Search(s,n,m);
129     cout << "插值查找" << m <<"的位置在:"<< a << endl << endl;
130
131     cout << "输入斐波那契查找要查找的数字: ";
132     cin >> m;
133     a = Fibonacci_Search(s,n,m,Fbi);
134     cout << "斐波那契查找" << m <<"的位置在:"<< a << endl << endl;
135
136     system("pause");
137 }

运行结果:

时间: 2024-01-06 04:55:44

顺序表查找和有序表查找的相关文章

lua 表: 将一个有序表的顺序打乱

需求:将一个按顺序排放的表的顺序打乱 注意:该函数会修改掉原始表的数据,因为lua里表是传引用的 function Table_Rand(t) if t == nil then return end local tRet = {} local Total = table.getn(t) while Total > 0 do local i = math.random(1,Total) table.insert(tRet,t[i]) t[i] = t[Total] Total = Total -1

算法学习之查找算法:静态查找表(2)有序表查找

如果静态查找表是一个有序表,则可以使用折半查找. 折半查找的过程是:先确定待查记录所在的范围(区间),然后逐步缩小范围直到找到或找不到该记录为止.折半查找过程是以处于区间中间位置记录的关键字和给定值比较,若相等,则查找成功,若不等,则缩小范围,直至新的区间中间位置记录的关键字等于给定值或者查找区间的大小小于零时(表明查找不成功)为止. 关键字key与表中某一元素array[i]比较,有3种情况: 1.key==array[i],查找成功 2.key > array[i],待查找元素可能的范围是a

算法学习之查找算法:静态查找表(1)顺序表查找

引言: 对查找表一般的操作有:1.查询某个"特定的"数据元素是否在查找表中:2.检索某个"特定的"数据元素的各种属性:3.在查找表中插入一个数据元素:4.从查找表中删去某个数据元素. 静态查找表的操作只包括两种:1.查找某个"特定的"数据元素是否在查找表中:2.检索某个"特定的"数据元素的各种属性: 静态查找表又有四种表现形式:顺序表的查找.有序表的查找.静态树的查找.索引顺序表的查找. 静态查找涉及的关键字类型和数据元素类型

大话数据结构—顺序表、有序表、线性索引查找

查找 根据给定的某个值,在查找表中确定一个其关键字(唯一的标识一个记录)等于给定值的数据元素或数据记录. 静态查找:只查找,不修改元素[线性表.顺序查找.二分查找] 动态查找:查找时,插入或者删除元素[二叉排序树] 顺序表查找 顺序查找(针对静态查找表),也叫线性查找O(n),从头开始遍历,直到最后一个记录. 优化:添加哨兵 //有哨兵的顺序查找 int foo(int *a,int n,int key) { int i; a[0]=key;//哨兵 i=n; while(a[i]!=key)

15.有序表查找与线索索引查找

转载请表明出处:http://blog.csdn.net/u012637501 一.有序表查找 1.折半查找/二分查找算法 (1)基本思想:在顺序存储的有序表中,取中间纪录(a[mid]=key)作为比较对象,若给定值与中间纪录的关键字相等,则查找成功:若给定值小于中间纪录的关键字,则在中间纪录的左半区继续查找:若给定值大于中间纪录的关键字,则在中间纪录的右半边.不断重复上述过程,直到查找成功,或所有查找区域无记录,查找失败为止. (2)使用条件:线性表中的纪录是关键码有序的(通常是从小到大有序

java数据结构之有序表查找

这篇文章是关于有序表的查找,主要包括了顺序查找的优化用法.折半查找.插值查找.斐波那契查找: 顺序优化查找:效率极为底下,但是算法简单,适用于小型数据查找: 折半查找:又称为二分查找,它是从查找表的中间开始查找.查找结果只需要找其中一半的数据记录即可.效率较顺序查找提高不少.比较适用与静态表,一次排序后不在变化: 插值查找:与折半查找比较相似,只是把中间之mid的公式进行了变换将mid = (low+high)/2;换成了mid = low + (high - low) * (key - sum

有序表查找算法(折半,插值,斐波那契)

今天总结了有序表查找常用的三种算法与大家分享. 1.折半查找折半查找又称二分查找,它的基本思想是:在有序表中,取中间记录作为比较对象,若相等则查找成功:若给定值小于中间记录的关键字,则在中间记录左半区继续查找,若给定值大于中间值,则在又半区寻找,不断重复以上过程. 算法代码(java版) int binarySearch(int[] a,int key){ int low,high,mid; low = 0; high = a.length-1; while(low<=high){ mid =

7.2 有序表查找

先对线性表进行有序排列,之后进行查找 主要有折半查找,插值查找和斐波那契查找 它们的时间复杂度均是O(logn),显然远远好于顺序查找的O(n).但就平均性能来说,斐波那契查找要优于折半查找.可惜如果是最坏的情况,key=1,那么始终都处于左侧长半区在查找,则查找效率要低于折半查找. 还有比较关键的一点,折半查找是进行加法与除法运算,插值查找进行复杂的四则运算,而斐波那契查找只是进行最简单的加法运算,这种细微差别会影响最终的查找效率. 下面我们就用php来描述这三种算法 <?php header

[从今天开始修炼数据结构]有序表查找

一.折半查找 1,折半查找也没啥好说的,就跟大家翻微信通讯录一样,你想找个姓杨的,你随手往下一划,划到了个姓李的,那这时候你肯定要从李往下划,李之上的区域直接被你排除了. 所以我们要两个引用,一个指向首,一个指向尾,再要另外一个指针指向中间,你拿目标value跟midValue比较一下,就知道目标再mid之前还是之后了.假如说在mid之前,这时候你让指向尾部的引用,改为指向mid-1的位置,mid指向此时的首尾之间,继续比较,直到找到目标. 2,代码实现 package Search.Order