标签: data-structures

整数可以是8个字节,即2 ^ 64.很多价值观.

假设我想编写一个小程序,将这样的值存储在一个文件中:

3 1 5 6 2 8 9 0 1 2 ....

在任何时候我的值都不会高于9.所以我只需要10个组合,我可以通过仅采用2 ^ 4(16种组合)的数据类型获得.不是2 ^ 64.

不会更有效率......我怎么能做到这一点.C++是否具有本机单数字类型.

我是Python的新手,并试图学习算法,我想问一下,为什么low < hi在查看列表时使用它是逻辑错误,正确的逻辑操作是low <= hi什么,它阻止的边缘情况.

def binary_search(input_array, value):
    """Your code goes here."""
    #O(log(n))
    low = 0
    hi = len(input_array) - 1 
    while low <= hi: #why cant it be low < hi
        mid = (low + hi)//2
        if input_array[mid] == value:
            return mid
        elif input_array[mid] < value:
            print(low, hi)
            low = mid + 1
        else:
            hi = mid - 1
    return -1


test_list = [1,3,9,11,15,19,29]
test_val1 = 25
test_val2 = 15
print(binary_search(test_list, test_val1))
print(binary_search(test_list, …

这是关于codefights的问题:

给定一个仅包含1到a.length范围内的数字的数组a,找到第二个匹配项具有最小索引的第一个重复数字.换句话说,如果有多于1个重复的数字,则返回第二次出现的索引小于另一个出现的第二次出现的索引的数量.

我一直在努力弄清楚如何在python中完成这个.我不确定我是否在正确的道路上,如果我是,我似乎无法弄清楚如何从我的字典中找到特定值后访问我的索引字典.我想在我的d字典中获取大于1的所有值,然后从索引中获取这些值,然后索引中较小的值将是答案.

如果我完全错了,请告诉我.

def firstDuplicate(a):
    d = {}
    index = {}

    for i in a:
        if i in d:
            d[i] += 1
        else:
            d[i] = 1

    for i,e in enumerate(a):
        if e in d:
            index[e] = i
        else:
            index[e] = i

    for key,val in d.items():
        if val > 1:

我最近开始学习数据结构.我写了一个哈希表根据这本书,使用二次探测法.这是代码:

class QuadraticProbingHashTable<E> implements HashTable<E> {
    private static final int DEFAULT_TABLE_SIZE = 11;

    private HashEntry<E>[] array;

    private int currentSize;

    public QuadraticProbingHashTable() {
        this(DEFAULT_TABLE_SIZE);
    }

    public QuadraticProbingHashTable(int size) {
        allocateArray(size);
        makeEmpty();
    }

    @SuppressWarnings("unchecked")
    private void allocateArray(int size) {
        array = new HashEntry[nextPrime(size)];
    }

    @Override
    public int size() {
        return currentSize;
    }

    @Override
    public boolean isEmpty() {
        return currentSize == 0;
    }

    @Override
    public void clear() {
        makeEmpty();
    }

    private void makeEmpty() {
        currentSize = 0;
        for (int i = 0; i …

我正在尝试使用C实现二进制Serach树.在此代码中,我向树中添加了几个值,然后尝试检查这些值是否在树中.但我尝试的代码总是返回true.

我已多次检查过.我还在学习C编程.

这是我的代码.

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct BSTnode {
    int data;
    struct BSTnode *left;
    struct BSTnode *right;
    } BSTnode;

BSTnode *getNewNode(int data){
    BSTnode *newNode = (BSTnode*)malloc(sizeof(BSTnode));
    newNode->data=data;
    newNode->left=newNode->right=NULL;
    }
BSTnode* InsertNew(BSTnode *root,int data){
    if(root == NULL){
        root = getNewNode(data);
                }
        else if(data <= root->data){
            root->left = InsertNew(root->left,data);
            } else{
                root->right = InsertNew(root->right,data);
                }
        return root;
        }

bool search(BSTnode *root, int data){
    if(root== NULL) return false;
    else if(root->data == data) return true;
    else if (data <= root->data) …

我对数据结构有疑问.有没有办法一次编辑整个结构,而不是一次编辑一个变量？FI:

struct foo
{
  int a=5;
  int b=4;
  int c=8;
};
int main()
{
    foo f;

    f-1;

    return 0;

}

结果:

  f.int a=4;
  f.int b=3;
  f.int c=7;

如果有办法做到这一点,那么在我正在制作的特定项目中,这将有很大帮助.无论如何,谢谢你的时间和帮助"D

我有一个这样的对象：

const users = {
 adam: {
   age: 28,
   extraInfo: 'foobar',
 },
 brad: {
   age: 31,
   extraInfo: 'foobar',
 },
 jef: {
   age: 12,
   extraInfo: 'baarfoo',
 },
};

如何检查哪个对象具有“ age”属性的最高值并将该对象设为常量？

我尝试过使用Object.keys（），将数据抛出到Array并进行减少，但最后，所有这些方法都无法按我的意愿工作。我已经在这个问题上停留了几个小时。

我想保留一个对象列表,以便我可以迭代它们并通过遍历它们中的每一个来通知它们每个事件.我不关心他们收到通知的顺序,我只需要尽可能快地对这些对象进行迭代和方法调用.

这类功能的最有效(C++标准库)数据结构是什么？

我有来自第三方库的两个结构,所以我不能改变它们的布局.但是我有两个我自己编写的结构符合它们的签名,所以我可以为它们添加函数(再次,但不是它们的布局,因此也没有虚函数).结构被称为Foo1和Foo2.两者都有相同的成员调用_b,但是在不同的偏移量.

struct FooBase { };

struct Foo1 : FooBase
{
    int _a = 2;
    int _b = 1;
};

struct Foo2 : FooBase
{
    int _b = 2;
};

struct Wrap
{
    Wrap(const FooBase& x) : _x(x) { }
    FooBase& _x;
    int GetValue() { return /* MISSING */; }
};

我有一个名为的包装类Wrap.我正在寻找一种方法来返回_bfoo类中不使用虚函数的值,因为我不能再改变它们的大小了.

Foo1 f1 = Foo1();
Wrap x = f1;
int a = x.GetValue(); // should return 1

Foo2 …

implicit val ord:Ordering[String] = Ordering.by(_.length)
var nameQueue = new PriorityQueue[String]()
nameQueue.+=("SINES","YINE","WIRAEUS")
nameQueue.foreach(println)

输出是:

WIRAEUS
YINE
SINES

这看起来令人困惑.任何人都可以帮助解释订购的机制吗？