c++ 编程题2

一个递增的正整数数组中找到 两个元素的和等于1个给定整数的算法。

void findSum (int data[], int count, int value) {

    int prev  = 0;
    int next  = count - 1;
    bool found = false;

    while (prev < next) {

        if (data[prev] + data[next] == value) {
            found = true;            
            break;
        }     
        else if (data[prev] + data[next] > value) {
            next--;
        }

        else if (data[prev] + data[next] < value) {
            prev++;
        }
    }

    if (found)
        cout << "result is:" << "Prev " << prev <<"-" << data[prev] << " next " << next << "-" << data[next] << endl;
    else
        cout <<"do not find the result";

}

2 一个长度为N的正整数有序数组（其值为1-N）中是否有重复元素

//1 - n, n
bool haveSameNumber(int data[], int n) {

    int*  back = new int[n + 1]; //skip the first element
    memset(back, 0, (n + 1) * sizeof(int));

    for (int i = 0; i < n; i++) {
       back[data[i]]++;
       if (back[data[i]] >= 2) {
           cout << "same number" << data[i] << endl;
           return true;
       }
    }

    delete back;

    return false;
}

3.  是否两个无序正整数数组完全相同（含有同样多的 元素， 例如数组1： 2 3 5 6 9 10 数组2：  2 5 6 3 10 9 ， 则这两个数组相同）

解答1： 如果数组中的元素值不大（例如都小于1000）：
 
bool same(int data[], int data2[], int len) {
    int* back = new int[len]; //skip the first element
    memset(back, 0, len  * sizeof(int));

    for (int i = 0; i < len; i++) {
       back[data[i]]++;
       back[data2[i]]--;
    }

    for (i = 0; i < len; i++) {
       if (back[i] != 0)
           return false;
       
    }

delete back;
    return true;
}

解答2： 数组中的元素值很大（如 1000000）

建立一个hash 表（其长度为要查找的数组长度），将遍历 两个数组，

如果hash表中没有这个元素， 则插入这个元素，

如果hash 表中有这个元素， 则删除这个元素。

void traverseItems(HashTable *table, int len, int value) {

        int index = value % len;        
        HashTable *item = table + index;
        HashTable *pre = NULL;
        
        while (item != NULL) {

            if (item->value == 0) { // the first item;
                item->value = value;
                return;
            }
            else if (item->value == value) { // find the item;
                if (pre != NULL) { // remove the item.
                    pre->next = item->next;
                    delete item;
                }
                else { // rewrite the first item
                    if (item->next == NULL)
                        item->value = 0;
                    else {
                        item->value = item->next->value;
                        item->next = item->next->next;
                        delete item->next;
                    }

                }
                return;
            }
            else { // find next item
                pre = item;
                item = item->next;
            }
        }

        if (item == NULL) { // insert the value
            item = new HashTable;
            memset(item, 0, sizeof(HashTable));
            item->value = value;
            // pre should not null at here
            assert(pre != NULL);
            pre->next = item;
        }

}

bool same2(int data[], int data2[], int len) {
    
    HashTable* back = new HashTable[len];

    memset(back, 0, len * sizeof(HashTable));

    for (int i = 0; i < len; i++) {
       
        int value = data[i];        
        traverseItems(back, len, value);
        value = data2[i];        
        traverseItems(back, len, value);
       
    }

    for (i = 0; i < len; i++) {
        if ((back + i)->value != 0) {
            cout << " the same 2 is not same" << endl;
           return false;
        }
       
    }
    delete back;
    cout << " the same 2 is same" << endl;
    return true;
}