二分查找算法在C/C++程序中的应用示例
作者：wuzhekai1985
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了二分查找算法在C/C++程序中的使用示例,文中最后提到了使用二分查找法一个需要注意的地方,需要的朋友可以参考下
&二分查找算法的思想很简单，《编程珠玑》中的描述： 在一个包含t的数组内，二分查找通过对范围的跟综来解决问题。开始时，范围就是整个数组。通过将范围中间的元素与t比较并丢弃一半范围，范围就被缩小。这个过程一直持续，直到在t被发现，或者那个能够包含t的范围已成为空。
&&&&&&& Donald Knuth在他的《Sorting and Searching》一书中指出，尽管第一个二分查找算法早在1946年就被发表，但第一个没有bug的二分查找算法却是在12年后才被发表出来。其中常见的一个bug是对中间值下标的计算，如果写成(low+high)/2，当low+high很大时可能会溢出，从而导致数组访问出错。改进的方法是将计算方式写成如下形式：low+ ( (high-low) &&1)即可。下面给出修改后的算法代码：
int binarysearch1(int a[],int n,int x)
int l,u,m;
while(l&u)
m=l+((u-l)&&1);
if(x&a[m])
else if(x==a[m])
return -1;
&&&&&& 这里注意一点，由于使用的是不对称区间，所以下标的调整看上去有点不规整。一个是u=m，另一个是l=m+1。其实很好理解，调整前区间的形式应该是 [ )的形式，如果中间值比查找值小，那么调整的是左边界，也就是闭的部分，所以加1；否则，调整是右边界，是开的部分，所以不用减1。调整后仍是[ )的形式。当然也可以写成对称的形式。代码如下：
int binarysearch1(int a[],int n,int x)
int l,u,m;
l=0;u=n-1;
while(l&=u)
m=l+((u-l)&&1);
if(x&a[m])
else if(x==a[m])
return -1;
&&&&&& 这样也看上去比较规整，但是有个不足。如果想把程序改成“纯指针”的形式，就会有麻烦。修改成纯指针的代码如下：
int binarysearch2(int *a,int n,int x)
int *l,*u,*m;
l=a;u=a+n-1;
while(l&=u)
m=l+((u-l)&&1);
else if(x==*m)
return m-a;
return -1;
&&&&&& 当n为0时，会引用无效地址。而用非对称区间则不会有这个问题。代码如下：
int binarysearch2(int *a,int n,int x)
int *l,*u,*m;
l=a;u=a+n;
while(l&u)
m=l+((u-l)&&1);
else if(x==*m)
return m-a;
return -1;
&&&&&& 上面给出的二分查找是迭代法实现，当然也可以用递归的方式实现。代码如下：
int binarysearch3(int a[],int l,int u,int x)
int m=l+((u-l)&&1);
if(x&a[m])
return binarysearch3(a,l,m-1,x);
else if(x==a[m])
return binarysearch3(a,m+1,u,x);
return -1;
&&&&&& 上述这些二分算法，若数组元素重复，返回的是重复元素的某一个元素。如果希望返回被查找元素第一次出现的位置，则需要修改代码。下面给出了一种解法：
int binarysearch4(int a[],int n,int x)
int l,u,m;
int flag=-1;
while(l&u)
m=l+((u-l)&&1);
if(x&a[m])
else if(x==a[m])
&&&&&& 下面是《编程珠玑》上的解法：
int binarysearch4(int a[],int n,int x)
int l,u,m;
while(l+1&u)
m=l+((u-l)&&1);
if(a[m]&x)
return (u&=n||a[u]!=x)?-1:u;
&&&&&&& 至此二分算法的代码讨论结束，下面讨论一下程序的测试问题。《代码之美》有一章专门介绍二分查找算法的测试，非常漂亮。这里班门弄斧，简单给出几个测试用例。针对binarysearch1。测试程序如下：
#include &iostream&
#include &cassert&
#include &algorithm&
#include &ctime&
int calmid(int l,int u) { return l+((u-l)&&1); }
int binarysearch1(int a[],int n,int x);
#define bs1 binarysearch1
int main()
long start,
start=clock();
int a[9]={-,-13,-10,-5,-3,0,1,400,};
//中值下标计算的测试
assert(calmid(0,1)==0);
assert(calmid(0,2)==1);
assert(calmid(0000)==1500000);
assert(calmid(,)==);
assert(calmid(,)==);
//冒烟测试
assert(bs1(a,9,0)==5);
assert(bs1(a,9,1)==6);
assert(bs1(a,9,2)==-1);
//边界测试
assert(bs1(a,0,1)==-1);
assert(bs1(a,1,-)==0);
//1个元素 成功
assert(bs1(a,1,-)==-1);
//1个元素 失败
assert(bs1(a,9,-)==0);
//首个元素
assert(bs1(a,9,-3)==4);
//中间元素
assert(bs1(a,9,)==8);
//末尾元素
//自动化测试
int b[10000];
for(i=0;i&10000;i++)
b[i]=i*10;
for(j=0;j&=i;j++)
assert(bs1(b,i+1,j*10)==j);
assert(bs1(b,i+1,j*10-5)==-1);
//自动化测试 引入随机数
srand(time(0));
for(i=0;i&10000;i++)
b[i]=rand()%1000000;
sort(&b[0],&b[i]);
for(j=0;j&=i;j++)
int x=rand();
int k=bs1(b,i+1,x);
assert(b[k]==x);
end=clock();
cout&&(end-start)/1000.0&&'s'&&
&&&&&& 注意到数组的元素有正数，负数，零，最大值，最小值。通常会忘掉负数的测试，引入最大值和最小值，主要是为了边界测试。
&&&&&& 第一，测试了中值下标的计算。另外写了一个小函数，单独测试。考虑到内存可能放不下这么大的数组，因此只是模拟测试，并没有真正申请这么大的空间，但是对于中值下标的测试足够了。
&&&&&& 第二，冒烟测试。即做一些最基本的测试。测试通过后进行边界测试。
&&&&&& 第三，边界测试。这里有三种类型，一是针对数组元素个数，分别是0个，1个。二是针对元素位置，分别是首个元素，中间元素，末尾元素。三是针对元素值，有最大值，最小值，0等测试。
&&&&&& 第四，自动化测试。这里自动生成测试的数组，然后针对每个元素进行成功查找测试。
&&&&&& 第五，自动化测试，只不过数组的元素是随机值。
&&&&&& 第五，性能测试。这里相关代码没有列出。以上测试都通过时，可以修改查找算法，添加性能测试的代码。其实可以简单添加一个比较的计数器。返回值从原来的查找结果改为比较的计数器值即可。代码比较简单，就不列了。
Note：二分查找容易忽略的一个bug
对于二分查找算法，相信大家肯定不会陌生。算法从一个排好序的数组中找指定的元素，如果找到了返回该元素在数组中的索引，否则返回-1。下面给出了解法。
//a为排好序的数组，n为数组的大小，x为指定元素
int binarySearch(int a[], int n, int x)
int left = 0, right = n-1, middle = 0;
int tmp = 0;
while(left &= right)
middle = (left + right)/2;
tmp = a[middle];
if(x & tmp) right = middle - 1;
else if(x & tmp) left = middle + 1;
return -1;
&&&&& 乍看没有错误，但是不幸的是，该程序存在一个bug。当数组极大时，(left+right)可能为负数，则数组下标溢出，程序崩溃。
解决的方案：将middle=(left+right)/2改为middle=left+(right-left)/2即可。即利用减法代替加法，从而消除上溢。
&&&&& 参考自《代码之美》
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具excel中2个公式left与right在表格中的运用详解
在日常工作中我们经常会因为一些数据不能从表格中分离出来而烦恼，今天我在这里为大家介绍2个简单的公式left与right在表格中的运用，会使大家在日常的工作中方便许多。
1.首先我们打开一张表格，在表格中随便输入一些数据，我输入的数据如图所示（当然大家也可以自己的输入一些日期或者是文字，方法是一样的结果就会一样
2.选中一个空的单元格，此单元格是用来运用LEFT函数我们分离出来的数据生成的单元格，如图Text是要提取字符的单元格，Num_chars是指从选中的单元格中从左数的几位字符，图中是指从A1单元格中左数2位字符。
3.由第二步操作公式后，我们得出来下面的结果如图， A1单元格中从左数2位字符是40就像我们看到的确实就是40。
4.right公式的使跟left公式基本是相同的，它们对需要分离的单元格的要求是一样的，不同的是公式中：Num_chars是指从选中的单元格中从右数的几位字符，下面是直接从right公式开始分析，如图中的公式所示，
5.由right公式操作后呈现出来的结果如图所示，A1是需要分离的单元格，2是指从A1单元格右数的2位字符，结果就是我们看到的66，这个是就这2个公式简单的运用，希望可以帮忙到大家
right公式与left公式大家在使用的时候要注意不要弄混了，公式的前部分是一样的，但是它们是从选中单元格的不同边开始数的这点大家一定要注意。
以上就是excel中2个公式left与right在表格中的运用详解，希望能对大家有所帮助！
如果您喜欢本文请分享给您的好友，谢谢！
评论列表（网友评论仅供网友表达个人看法，并不表明本站同意其观点或证实其描述）二分查找无bug版
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。二分查找可以找到元素在数组中的下标位置，而查找树由于采用的是树结构，所以只能判断出元素是不是在树中以及给出最大/小值，而不能确定指定元素的确切位置。
#include&vector&
#include&iostream&
#include&algorithm&
#include&cstdlib&
#include&iomanip&
//cout格式化输出
#include&ctime&
const int NOT_FOUND=-1;
const long MUL=16807L;
const long ADD=13849;
const long MOD=0x7fffffffL;
//线性同余法产生无符号随机数
inline unsigned myRand(){
static long seed=(long)time(NULL);
seed=(seed*MUL+ADD)%MOD;
return (unsigned)seed&&17;
//linear congruential method高16位随机性比较好,我们只用它的高15位,返回值在[0,32767]
template &typename Comparable&
int binarySearch(const vector&Comparable& & a,const Comparable & x){
int low=0;
int high=a.size()-1;
while(low&=high){
int mid=(low+high)/2;
if(x&a[mid])
low=mid+1;
else if(x&a[mid])
high=mid-1;
return NOT_FOUND;
int main(){
clock_t begin=clock();
vector&int&
for(int i=0;i&1000000;i++)//生成一百万个随机数进行排序
v.push_back((int)myRand());
sort(v.begin(),v.end());
int position=binarySearch(v,20109);
clock_t finish=clock();
long elapse=(long)(finish-begin);
cout&&&find the element in position: &&&position&&
cout&&&elapsed time:&&&setprecision(5)&&(float)elapse/CLOCKS_PER_SEC&&&s&&&
clock_t的值转换为秒应该是除以CLOCKS_PER_SEC这个宏，而这个宏在Windows平台下是1000，而到了Linux平台下就是1000000了
#include&iostream&
#include&iomanip&
const long MUL=16807L;
const long ADD=13849L;
const long MOD=0x7fffffffL;
//线性同余法产生无符号随机数
inline unsigned myRand(){
static long seed=(long)time(NULL);
seed=(seed*MUL+ADD)%MOD;
return (unsigned)seed&&17;
//linear congruential method高16位随机性比较好,我们只用它的高15位,返回值在[0,32767]
//定义平衡二叉树
struct AvlNode{
AvlNode(const int & theElement,AvlNode *lt,AvlNode *rt,int h=0):
element(theElement),left(lt),right(rt),height(h){}
//计算节点的高度
int height(AvlNode * t){
return t==0?-1:t-&
//返回两个整值的最大者
int max(const int l,const int r){
void rotateWithLeftChild(AvlNode * & k2){
AvlNode *k1=k2-&
k2-&left=k1-&
k1-&right=k2;
k2-&height=max(height(k2-&right),height(k2-&left))+1;
k1-&height=max(height(k1-&left),k2-&height)+1;
void rotateWithRightChild(AvlNode * & k2){
AvlNode *k1=k2-&
k2-&right=k1-&
k1-&left=k2;
k2-&height=max(height(k2-&left),height(k2-&right))+1;
k1-&height=max(height(k1-&right),k2-&height)+1;
//左--右旋
void doubleWithRightChild(AvlNode * & k3){
rotateWithLeftChild(k3-&right);
rotateWithRightChild(k3);
//右--左旋
void doubleWithLeftChild(AvlNode * & k3){
rotateWithRightChild(k3-&left);
rotateWithLeftChild(k3);
//插入新节点
void insert(const int & x,AvlNode * & t){
t=new AvlNode(x,0,0);
else if(x&t-&element){
insert(x,t-&left);
if(height(t-&left)-height(t-&right)==2){
if(x&t-&left-&element)
rotateWithLeftChild(t);
doubleWithLeftChild(t);
else if(x&t-&element){
insert(x,t-&right);
if(height(t-&right)-height(t-&left)==2){
if(x&t-&right-&element)
rotateWithRightChild(t);
doubleWithRightChild(t);
;//DDo nothing
t-&height=max(height(t-&left),height(t-&right))+1;
//判断树中是否包含要查找的节点
bool contains(const int & x,AvlNode * t){
else if(x&t-&element)
return contains(x,t-&left);
else if(x&t-&element)
return contains(x,t-&right);
int main(){
clock_t begin=clock();
AvlNode * root=new AvlNode(0,0,0);
for(int i=0;i&1000000;i++)//生成一百万个随机数进行排序
insert((int)myRand(),root);
if(contains(20109,root))
cout&&&find&&&
cout&&&not find&&&
clock_t finish=clock();
long elapse=(long)(finish-begin);
cout&&&elapsed time:&&&setprecision(5)&&(float)elapse/CLOCKS_PER_SEC&&&s&&&
生成一百万个随机数，在我的机子上进行查找，运行次的平均时间（建立存储结构查找时间）：秒&&
平衡二叉查找树
php二分查找示例 二分查找常用写法有递归和非递归，在寻找中值的时候，可以用插值法代替求中值法。当有序数组中的数据均匀递增时，采用插值方法可以将算法复杂度从中值法的lgN减小到lglgN
/** * 二分查找递归解法 * @param type $subject * @param type $start * @param typ
一般二分都用到int[]型上.....在js中可能会更灵活的用到a-z上，或者用到拼音...或者用到......
不过值得深思的一个问题是，如果为了实现对拼音之类的二分查找.而经过如下流程是否值得：
1。对拼音排序，貌似代码量不小吧。
2。然后再二分查找。这又需要识别拼音的大小，貌似也不算太小吧。
找到结果的速度快了，可是别人下你的js文件速度慢多了，呵呵，到底舍弃谁。
下面的代码甚至可
第一种方法: 【二分查找要求】：1.必须采用顺序存储结构 2.必须按关键字大小有序排列。 　　 【优缺点】折半查找法的优点是比较次数少，查找速度快，平均性能好;其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而查找频繁的有序列表。 　　 【算法思想】首先，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如
class search{// 查找的源数组private $array = array(1,2,3,5,7,6,4,8);/** * 顺序查找法 * @param $val 要查找的值 */public function query_search($val){&nb
二分法查找数组是否包含某一元素，兼容正反序，代码实现：
$searchValue = (int)$_GET['key'];
function search(array $array, $value) {
$max = count($array)-1; &nb
问题背景 今年的实习生招聘考试，我出了一道二分查找(Binary Search)的题目。题目大意如下： 给定一个升序排列的自然数数组，数组中包含重复数字，例如：[1,2,2,3,4,4,4,5,6,7,7]。问题：给定任意自然数，对数组进行二分查找，返回数组正确的位置，给出函数实现。注：连续相同的数字，返回第一个匹配位置还是最后一个匹配位置，由函数传入参数决定。
我为什么会出这道题目？
&?php /** * 查找 * **/ // 顺序查找 function normal_search($arrData,$val) { $len = count($arrData); if($len == 0) return -1; for($i = 0;$i & $ $i++ ) { echo &find No.&,$i + 1,&quo
&?php //search函数 其中$array为数组，$k为要找的值，$low为查找范围的最小键值，$high为查找范围的最大键值 function search($array, $k, $low=0, $high=0) { if(count($array)!=0 and $high == 0) //判断是否为第一次调用 { $high = count($array);
1.算法：（设查找的数组期间为array[low, high]） （1）确定该期间的中间位置K（2）将查找的值T与array[k]比较。若相等，查找成功返回此位置；否则确定新的查找区域，继续二分查找。区域确定如下：a.array[k]&T 由数组的有序性可知array[k,k+1,……,high]&T;故新的区间为array[low,……，K-1]b.array[k]&T 类似上
在Javascript中，我们可以通过prototype关键字为对象添加新的属性或者是方法，下面是一个为Array对象添加二分法查找功能的方法：
Array.prototype.binarySearch = function(obj) { var value = 0; var left = 0; var right= this. while(left &=
python中的二叉树模块内容： BinaryTree：非平衡二叉树 AVLTree：平衡的AVL树 RBTree：平衡的红黑树
以上是用python写的，相面的模块是用c写的，并且可以做为Cython的包。 FastBinaryTree FastAVLTree FastRBTree
特别需要说明的是：树往往要比python内置的dict类慢一些
上一篇文章中谈到的前缀树实现方式，时间复杂度从理论上来讲已经达到了最优，而空间复杂度理论上也可以做到较优。但是理论和实际是有差别的，而对于上文前缀树的实现来说，这两方面并不是非常理想：
时间：前缀树时间复杂度为O(m)的前提是每次哈希表查找操作的时间复杂度为O(1)，不过这个O(1)与一次数值比较相比，从性能上来说还是有比较明显的差距。
空间：前缀树空间复杂度较优的前提是“精细”地实现该数据结
为什么建了索引后查找记录会更快？
1. 索引文件是有序的，查找时可以用二分法或其他基于树型结构的查找法; 而记录文件不一定有序，时间复杂度可能等于记录数。
2. 索引文件存储字段较少，占用的block数比数据文件少，在索引文件中遍历，所需的I/O时间会短很多。
3. 索引文件如果足够小，可以直接放内存里，这样遍历起来就更快了。
&html& &head& &meta http-equiv=&Content-Type& content=&text/charset=utf-8&& &script type=&text/javascript&&
AVL-tree、RB-tree、AA-tree均可以实现平衡的二叉查找树，虽然相对于一般的二叉搜索树其插入、删除节点的平均时间会比较长，但它们可以避免极验证应付的最坏的情况--树高度不平衡。 平衡二叉查找树所谓的平衡并不是绝对的平衡，而是要求任何一个节点的左右子树高度相差不会超过1，此时仍能够保证树的“对数深度”。 在学习红黑树之前要先学习AVL树，了解一些旋转操作是怎么进行的。我之前写过AVL
15.有序表查找与线索索引查找
转载请表明出处：http://blog.csdn.net/u
一、有序表查找
1.折半查找/二分查找算法
(1)基本思想：在顺序存储的有序表中，取中间纪录(a[mid]=key)作为比较对象，若给定值与中间纪录的关键字相等，则查找成功；若给定值小于中间纪录的关键字，则在中间纪录的左半区继续查找；若给定值大于中间纪录的关键字，则在中
数据结构很重要，算法+数据结构+文档=程序
使用PHP描述冒泡排序算法，对象可以是一个数组
//冒泡排序（数组排序）function bubble_sort($array) { $count = count($array); if ($count &= 0) for($i=0; $i&$ $i++){ for($j=$co
测试效果图:
unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdC type TForm1 = class(TForm) Button1: TB Memo1: TM procedure
PHP几个算法整理 涉及到以下几个示例。PHP冒泡PHP二分法PHP求素数PHP乘法表 PHP冒泡法 示例
//PHP冒泡 从小到大 function maopao(&$arr) {
if(!empty($arr))
for($i=0;$i&count($arr);$i++) &nb
14.查找概论与顺序查找
一、查找概论
1.查找：即根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素(或纪录)。若表中不存在关键字等于给定值的纪录，则称查找不成功，此时查找的结果可给出一个&空&纪录或&空&指针。另外，查找表按照操作方式来分有两大种：静态查找表和动态查找表。
(1)查找表(Search table)：是由同一类型
最新IP地址数据库 二分逼近算法 高效解析800万大数据之区域分布
最新IP地址数据库来自利用二分逼近法(bisectionmethod)，解析800多万IP只需几十秒，比较高效！原来的顺序查找算法效率比较低
一种读者图书借阅二分网络中的优质图书迭代识别算法
为了给图书馆读者用户提供更满意的个性化推荐图书，我们必须在两方面做出有效的工作：一是如何来准确的识别用户可能感兴趣的图书主题或者类别，不像图书，读者用户一般没有完整直接的兴趣特征标识。常用的方法往往是采用读者所借图书的主题信息来间接表达读者的兴趣特征，然而我们也注意到，读者在借阅时并非始终对某种既定主题保持着浓厚的兴趣，有时也因为能力和专业水平
Oracle、MYSQL、sql server和DB2分页查询写法
一、DB2: 　　DB2分页查询 　　SELECT * FROM (Select 字段1,字段2,字段3,rownumber() over(ORDER BY 排序用的列名 ASC) AS rn from 表名) AS a1 WHERE a1.rn BETWEEN 10 AND 20 　　以上表示提取第10到20的纪录 　　sel
关于oracle开窗函数--2分析函数参考手册
Oracle 9i 分析函数参考手册 Oracle从8.1.6开始提供分析函数，分析函数用于计算基于组的某种聚合值，它和聚合函数的不同之处是对于每个组返回多行，而聚合函数对于每个组只返回一行。 下面例子中使用的表来自Oracle自带的HR用户下的表，如果没有安装该用户，可以在SYS用户下运行$ORACLE_HOME/demo/schema/huma
1、Locate: 根据字段列表和对应的字段值查找并定位, 找到返回 True.
2、Lookup: 根据字段列表和对应的字段值查找, 返回需要的字段值.
3、SetKey、GotoKey 或 SetKey、GotoNearest: 根据索引字段的值查找, 先切换状态再根据条件定位.
4、FindKey 或 FindNearest: 根据索引字段的值查找.
其中的 GotoN
先来看看什么是书签查找：
　　　　当优化器所选择的非聚簇索引只包含查询请求的一部分字段时，就需要一个查找（lookup）来检索其他字段来满足请求。对一个有聚簇索引的表来说是一个键查找（key lookup），对一个堆表来说是一个RID查找（RID lookup）。这种查找即是――书签查找。
　　　书签查找根据索引的行定位器从表中读取数据。因此，除了索引页面的逻辑读取外，还需要数据页面的逻辑读取
你可以输入'脚本'查查看 查找页面中的字符 &script language=&JavaScript&& var NS4 = (document.layers); // Which browser? var IE4 = (document.all); var win = // window to search. var n = 0; function
考察数据结构——第一部分:数据结构简介
考察数据结构——第二部分：队列、堆栈和哈希表
原文链接：Part3: Binary Trees and BSTs
本文是&考察数据结构&系列文章的第三部分，讨论的是.Net Framework基类库没有包括的常用数据结构：
二叉树。就像线形排列数据的数组一样，我们可以将二叉
有过相关经验的朋友都知道，Jscript的效率毕竟有限，在数组中查找数据时如果用常规的算法来做执行起来会很慢。 例如在一个含500个字符串的data数组里，我们想要找到一个指定的字符（key），返回它的数组下标，如果用这样的算法： [Copytoclipboard]CODE: functionusual_search(data,key) { varm
//set是一个排序后的容器,该容器不容许重复.//map用来存储排序后的键值对,键必须唯一.//set和map支持在最坏情况下对基本操作insert,erase和find仅消耗对数时间.//相应的底层实现是平衡二叉树.典型的用法不是使用AVL树,而常常是使用自顶向下的红黑树.//set和map的每一个元素都是一个pair的实例. 1 #include & iostream &
指令名称：whereis功能介绍：在特定目录中查找符合条件的文件。这些文件的烈性应属于原始代码，二进制文件，或是帮助文件。语法格式：whereis [-bfmsu][-B &目录&...][-M &目录&...][-S &目录&...][文件...]常用参数说明：　-b 　只查找二进制文件。 　-B &目录& 　只在设置的目录下查找二进制文件。 　-
如何查找索引对应字段
首先了解一下sql server系统表：sys.indexes 索引sys.objects 对象（表...）sys.columns 字段sys.index_columns 索引_字段sys.tables 自定义表【具体信息不多解释】
已知有employeeinfo表，字段名为userid是唯一键（索引名为IX_employeeinfo）问题1，如何查找索引对应
FindWindow( lpClassName, {窗口的类名} lpWindowName: PChar {窗口的标题} ): HWND; {返回窗口的句柄; 失败返回 0} //FindWindowEx 比 FindWindow 多出两个句柄参数: FindWindowEx( Parent: HWND; {要查找子窗口的父窗口句柄} Child: HWND; {子窗口句柄} ClassName:
查找某表上的约束
查找约束的方法如下：
（ 1 ） 查找某表上的约束
select * from user_constraints
where table_name= 'MEDIA'
有时想删除一个表上的记录 , 由于创建的约束比较多 , 不知道约束在哪
一.以文件名查找：1. find 命令find / -name &filename&目的：在根目录“/”开始搜被称为filename的文件，“filename”文件名可以包含通配符（*，？），注意：filename是文件名字符串，可以带双引号，也可不带find命令功能强大，它有很多选项让你以不同的方式搜索文件，例如，通过日期，文件大小，权限，
如果遇到死锁了，怎么解决呢？找到原始的锁ID，然后KILL掉一直持有的那个线程就可以了， 但是众多线程，可怎么找到引起死锁的线程ID呢？ MySQL 发展到现在，已经非常强大了，这个问题很好解决。 直接从数据字典连查找。
我们来演示下。
线程A，我们用来锁定某些记录，假设这个线程一直没提交，或者忘掉提交了。 那么就一直存在，但是数据里面显示的只是SLEEP状态。
mysql& set
　　InDesign中经常会遇到很多需要查找与替换的文字编辑工作，在编排文字时设定好段落样式和字符样式，查找和替换的文字编辑工作将会变得更加简单和便捷。今天就向大家介绍InDesign的文字快速查找替换编辑技巧，希望对大家有所帮助！ 　　左图为需要查找替换文字原稿，右图为查找替换后的结果。 　　 　　步骤一：输入文本，并定义好段落样式。 　　 　　步骤二：执行“编辑&查找/更改”命令，弹出“
主要是利用查找/proc目录下的相关文件进行查找.
#!/usr/bin/ #usage: process_grep.pl ProcessName exit( main(@ARGV) ); sub main { my $P my $ProcessName = my $PROC_DIR = &/proc
使用ROWID查找和删除重复行
使用ROWID查找和删除重复行
SQL& create table tab4test(
2 c1 char(4),
3 c2 varchar2(20)
表已创建。
本文以查找车站名为例，仿12306官网查找车站售票时间页面效果，当用户输入关键字点击查找按钮或按回车键时，jQuery通过正则匹配内容，准确匹配关键字，并迅速将页面定位滚动到第一个匹配的位置，并显示相关信息（本例中附加信息为车站开始售票时间）。 HTML页面需要放置一个输入框用来输入要查找的关键字，以及一个查找按钮，然后就是主体内容#content，里面包含着n个&p&，即每个时间段开}