我使用xpath从xml文件填充了一个排序的日期列表(以dd/mm/yyyy格式存储为字符串).
但是,当查询列表以查看列表中是否存在日期时,我总是得到否定结果(即不存在),即使我有查询字符串的硬编码以匹配列表中的日期.
但是,当对包含查询字符串的索引进行字符串比较时,我得到0表示字符串是相同的.
什么可以导致这种奇怪的行为？
这里要求的是代码
假期包括:
while (iter.MoveNext())
{
XPathNavigator nav2 = iter.Current;
XPathNodeIterator iter2 = nav2.SelectDescendants("date", "", false);
while (iter2.MoveNext())
{
date = iter2.Current.ToString();
holidays.Add(date);
}
}
return holidays;
搜索是:
holidays = list.getHolidays();
if(holidays.BinarySearch(DateTime.Now.ToShortDateString()) > 0)
返回以下XML:
<date>01/01/2009</date>
<date>25/02/2009</date>
<date>10/04/2009</date>
<date>13/04/2009</date>
<date>04/05/2009</date>
<date>25/05/2009</date>
<date>31/08/2009</date>
<date>25/12/2009</date>
<date>28/12/2009</date>
所以,我想更多地了解二进制搜索,因为我真的不明白.二进制搜索需要一个数组排序的前提条件.我做对了吗？看起来一个方法应该检查这个前提条件并在不满足时抛出异常.但是,为什么检查前提条件是个坏主意？
我正在尝试在Python中编写一个函数,它找到排序列表中的第一个数字,该数字大于我作为参数传递的特定值.我在网上找到了使用简单列表推导来实现这一目的的例子,但出于我的目的,我需要经常在大型列表上执行此操作,因此在线性时间内运行的搜索过于昂贵.
虽然我遇到了一些无法正常工作的边缘情况,但我在编写迭代二进制搜索类函数时遇到了麻烦.顺便说一下,该功能不需要处理列表中没有较大项目的情况.这是我现有的功能:
def findFirstLarger(num, sortedList):
low = 0;
high = len(sortedList) - 1
mid = -1
while True:
print("low: " + str(low) + "\t high: " + str(high))
if (low > high):
print("Ah geez, low is " + str(low) + " and high is " + str(high))
return # debugging, don't want this to happen
if low == high:
return sortedList[low]
else:
mid = (low + high) / 2;
if num == sortedList[mid]:
return sortedList[mid]
elif num > sortedList[mid]:
low …我认为List<T>在我搜索的字段上排序会使搜索更快.假设我在对象模型中有List<Person>10.000和List<Car>10.000.我循环模型中的人员列表,并希望找到具有属性c.Owner == person.Name的Car.
public static Car Car(Model model, Person person)
{
return model.Cars.Find(
delegate(Car c)
{
return c.Owner.Equals(person.Name);
});
}
对财产所有者的汽车列表进行排序不会使循环更快？
我想也许我应该使用,BinarySearch但重载BinarySearch不允许代表.BinarySearch当您必须将要查找的汽车作为参数进行查询时,überhaupt的用途是什么？
我应该创建一个O(n log(n))算法,检查int [] ==给定数字中是否有2个数字的总和.
例如.鉴于[1,4,7,2,3,4]将有8(1 + 7)而不是20
给出的答案建议使用二进制排序或合并排序,但他们只给出了合并排序算法,而没有逻辑处理这个特殊要求.然后另一个答案是:
假设x是我们要检查的总和,z是此数组中的元素集:以下算法解决了以下问题:
- 在S中排序元素
- 形成集合S'= {z:z = x-y表示某些y∈S}.
- 对S'中的元素进行排序.
- 如果S中的任何值出现多次,则删除除一个实例外的所有值.为S'做同样的事情.
- 合并两个有序集S和S'.
- S中存在两个元素,当且仅当相同的值出现在合并输出的连续位置时,其总和才是x.
为了证明步骤4中的声明的合理性,首先观察如果在合并输出中出现两次任何值,它必须出现在连续的位置.因此,我们可以在步骤5中重述该条件,因为在S中存在两个元素,当且仅当相同的值在合并输出中出现两次时,其总和恰好为x.假设某个值w出现两次.然后在S中出现一次,在S'出现一次.因为w出现在S'中,所以存在一些y∈S,使得w = x-y,或x = w + y.由于w∈S,元素w和y在S中并且与x相加.
相反,假设存在值w,y∈S使得w + y = x.然后,由于x-y = w,值w出现在S'中.因此,w在S和S'中,因此它将在合并输出中出现两次.
步骤1和3需要O(n log n)步骤.步骤2,4,5和6需要O(n)步骤.因此总运行时间为O(n log n).
但我真的不是他们的意思.在第2步中,x和y是什么？
但是我自己在下面创建,我想知道它是O(n log(n))不是？
class FindSum {
public static void main(String[] args) {
int[] arr = {6,1,2,3,7,12,10,10};
int targetSum = 20;
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
int end = arr.length - 1;
if (FindSum.binarySearchSum(arr, targetSum, 0, end, 0, end)) {
System.out.println("Found!");
} else …我99%肯定我的问题是我每次开始都设置为低至零.但我不知道如何保持低一致代表低指数,无论我的递归深度.如果它准确地告诉我低指数的指数我不认为我会有问题.
到目前为止,这是我的代码:
int recBSearch(vector<int> v, int size, int item)
{
int index = size / 2;
int curr = v[index];
int low = 0;
int high = size -1;
if (v[index] == item)
return index;
else if (v[index] > item)
{
high = index;
index = (high+low)/2;
size = high - low;
return recBSearch(v, size, item);
}
else if (v[index] < item)
{
low = index;
index = (high+low)/2;
size = high - low;
return recBSearch(v, size, item);
}
return …我有一个排序数组double.目标是在Array中查找索引.其中包含<=搜索值的值.
例如,数组包含{0, 5, 12, 34, 100}索引范围为[0 .. 4]的数字.
搜索值= 25.我想得到指数= 2(出现的范围在12到34之间)
我不明白在这种情况下如何运行二进制搜索.
public class MyComparer : IComparer<double>
{
public int Compare(double x, double y)
{
//<-------- ???
}
}
public double[] spline_x;
MyComparer cmpc = new MyComparer();
int i=Array.BinarySearch(spline_x, x, cmpc);
我创建了一个程序来查找数字列表的中位数.数字列表是动态的,可以删除和插入数字(可以输入重复的数字),在此期间,重新评估和打印新的中位数.
我使用multimap创建了这个程序,因为
1)它已经被分类的好处,
2)容易插入,删除,搜索(因为多图实现二进制搜索)
3)允许重复的条目.
条目数+删除数(表示为N)的约束是:0 <N <= 100,000.
我写的程序工作并打印出正确的中位数,但速度不够快.我知道unsorted_multimap比multimap快,但是unsorted_multimap的问题是我必须对它进行排序.我必须对它进行排序,因为找到你需要有一个排序列表的中位数.所以我的问题是,使用unsorted_multimap然后快速排序条目是否可行,或者这只是荒谬的？使用矢量,快速导航矢量和使用二分搜索会更快吗？或者也许我忘记了一些我甚至都没想过的神话般的解决方案.
虽然我不是C++的新手,但我会承认,我的时间复杂性技巧在某种程度上是医学上的.
我越是看自己的问题,我越开始认为只使用带快速排序和二进制搜索的向量会更好,因为数据结构基本上已经实现了向量.
我是二叉树的初学者,并且一直在通过算法书.我已经了解了BST的各种遍历方法(预订,后期订单等).
有人可以解释一下如何通过BST来计算离开的节点数(没有孩子)吗？
非常感谢!
我正在尝试编写二进制搜索函数来查找fun区间中函数的根[,]:
这是我所拥有的,但却遗漏了标记:
def binarySearchIter(fun, start, end, eps=1e-10):
'''
fun: funtion to fund the root
start, end: the starting and ending of the interval
eps: the machine-precision, should be a very small number like 1e-10
return the root of fun between the interval [start, end]
'''
root = (start + end)/2
print(root)
answer=fun(root)
if abs(answer) <= eps:
print(root)
return root
elif answer - eps > 0:
binarySearchIter(fun, start, root, eps=1e-10)
else:
binarySearchIter(fun, root, end, eps=1e-10)
这是我用来测试的功能:
def …