查找数组中重复的数字

Posted 2020-09-29 DHUtoBUAA

        题目来源于《剑指Offer》中的面试题3：找出数组中重复的数字。
　　// 题目：在一个长度为n的数组里的所有数字都在0到n-1的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，
　　// 也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。例如，如果输入长度为7的数组{2, 3, 1, 0, 2, 5, 3}，
　　// 那么对应的输出是重复的数字2或者3。

        解决方法有多种，包括数组排序，哈希表法，以及作者推荐的重排数组法。此处介绍自己的一个做法，以空间换时间，通过新建数组来实现快速查找，具体做法是新建长度为length的数组newArray，初始化值为-1；将numbers数组的值依次作为newArray的下标和对应的值为newArray赋值，其中number向newArray赋值时，判断newArray对应下标是否为-1，如果不为-1则表示newArray曾被相同的数赋值，说明有重复的数存在。以数组｛2,3,1,0,2,5,3｝为例，新建长度为7的数组｛-1，-1，-1，-1，-1，-1，-1｝，依次赋值为｛-1，-1，2，-1，-1，-1，-1｝，｛-1，-1，2，3，-1，-1，-1｝，｛-1，1，2，3，-1，-1，-1｝，｛0，1，2，3，-1，-1，-1｝，下一次将2赋值给新数组时，发现新数组中下标为2的为2，说明曾被2赋值，说明2是重复的。

#include<cstdio>

// 参数:
//        numbers:     一个整数数组
//        length:      数组的长度
//        duplication: (输出) 数组中的一个重复的数字
// 返回值:             
//        true  - 输入有效，并且数组中存在重复的数字
//        false - 输入无效，或者数组中没有重复的数字
//bool duplicate(int numbers[], int length, int* duplication)
//{
//    // int* duplication 使用指针类型的形参访问函数外部的对象，通过指针可以访问和修改指向的对象，但是拷贝的指针是两个不同的指针
//    // 建议使用引用类型的形参替代指针
//    if (numbers == nullptr || length <= 0)
//        return false;
//
//    for (int i = 0; i < length; ++i)
//    {
//        if (numbers[i] < 0 || numbers[i] > length - 1)
//            return false;
//    }
//
//    for (int i = 0; i < length; ++i)
//    {
//        while (numbers[i] != i)
//        {
//            if (numbers[i] == numbers[numbers[i]])
//            {
//                *duplication = numbers[i];  //解引用
//                return true;
//            }
//
//            // 交换numbers[i]和numbers[numbers[i]]             
//            int temp = numbers[i];
//            numbers[i] = numbers[temp];
//            numbers[temp] = temp;
//        }
//    }
//    return false;
//}

/*
    我的新方法：
    新建长度为length的数组newArray，初始化值为-1；
    将numbers数组的值作为newArray的下标和对应的值为newArray赋值，
    其中number向newArray赋值时，判断newArray对应下标是否为-1，
    如果不为-1则表示newArray曾被相同的数赋值，说明有重复的数存在
*/
bool duplicate(int numbers[], int length, int* duplication)
{
    // 过滤掉空指针和不符合规定的输入
    if (numbers == nullptr || length <= 0)
        return false;

    for (int i = 0; i < length; ++i)
    {
        if (numbers[i] < 0 || numbers[i] > length - 1)
            return false;
    }

    int* tempArray = new int[length]; //动态数组
    for (int * q= tempArray;q!= tempArray+length;++q)
    {
        // 遍历数组初始化
        *q = -1;
    }
    for (int j = 0; j < length; j++)
    {
        if (tempArray[numbers[j]] == -1)
            tempArray[numbers[j]] = numbers[j];
        else if(tempArray[numbers[j]]== numbers[j])
        {
            //曾被赋值一次或多次
            *duplication = numbers[j];  //解引用
            delete [] tempArray;
            return true;
        }
    }
    delete [] tempArray; //删除指向数组的指针，不可省略方括号
    return false;
}

// ====================测试代码====================
bool contains(int array[], int length, int number)
{
    for (int i = 0; i < length; ++i)
    {
        //只要有一个符合，即返回True
        if (array[i] == number)
            return true;
    }
    return false;
}

void test(char* testName, int numbers[], int lengthNumbers, int expected[], int expectedExpected, bool validArgument)
{
    printf("%s begins: ", testName);
    // expected[];  重复结果
    // expectedExpected; 重复数量 
    int duplication;  //自定义函数重复数
    bool validInput = duplicate(numbers, lengthNumbers, &duplication);

    if (validArgument == validInput)
    {
        //是否有重复
        if (validArgument)
        {
            if (contains(expected, expectedExpected, duplication))
                printf("Passed.\n");
            else
                printf("FAILED.\n");
        }
        else
            printf("Passed.\n");
    }
    else
        printf("FAILED.\n");
}

// 重复的数字是数组中最小的数字
void test1()
{
    int numbers[] = { 2, 1, 3, 1, 4 };
    int duplications[] = { 1 };
    test("Test1", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int), true);
}

// 重复的数字是数组中最大的数字
void test2()
{
    int numbers[] = { 2, 4, 3, 1, 4 };
    int duplications[] = { 4 };
    test("Test2", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int), true);
}

// 数组中存在多个重复的数字
void test3()
{
    int numbers[] = { 2, 4, 2, 1, 4 };
    int duplications[] = { 2, 4 };
    test("Test3", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int), true);
}

// 没有重复的数字
void test4()
{
    int numbers[] = { 2, 1, 3, 0, 4 };
    int duplications[] = { -1 }; // not in use in the test function
    test("Test4", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int), false);
}

// 没有重复的数字
void test5()
{
    int numbers[] = { 2, 1, 3, 5, 4 };
    int duplications[] = { -1 }; // not in use in the test function
    test("Test5", numbers, sizeof(numbers) / sizeof(int), duplications, sizeof(duplications) / sizeof(int), false);
}

// 无效的输入
void test6()
{
    int* numbers = nullptr;
    int duplications[] = { -1 }; // not in use in the test function
    test("Test6", numbers, 0, duplications, sizeof(duplications) / sizeof(int), false);
}

void main()
{
    test1();
    test2();
    test3();
    test4();
    test5();
    test6();
    getchar();
}