算法面试题之数组中重复的数字

题目

找出数组中重复的数字，其中，长度为n的数组里的所有数字都在0~n-1的范围内

例如：如果输入长度为7的数组{2,4,1,4,5,6,1}，那么对应的输出是重复的数字4或者1。

解决思路

解决任何问题的思路都是由简到难，由大到小。衡量一个算法优劣的标准是其时间复杂度和空间复杂度的大小，时间复杂度以及空间复杂度越小，说明该算法越好。

思路1

解决该问题最简单也是最容易想到的方法是先把数组进行排序，然后遍历排序的数组，那就很容易找出重复的数字了。该算法的时间复杂度主要产生于排序中，而当前的排序算法时间复杂度小的算法有快速排序、堆排序和归并排序，时间复杂度均为$O(nlogn)$，因此该算法的时间复杂度为$O(nlogn)$。下面是该算法选择快速排序作为排序算法的Java程序：

package TempFile;

/**
 * Created by 余沾.
 */
public class Test {

    /*
     * 利用排序思路求出数组中重复的数字
     */
    int duplicate(int sortedArr[])
    {
        if(sortedArr[0] < 0 || sortedArr[sortedArr.length-1] >= sortedArr.length)//数组的所有值都必须在0~n-1内
            throw new IllegalArgumentException("数组不合法");
        int i;
        for(i = 1;i < sortedArr.length;i++)
        {
            if(sortedArr[i] == sortedArr[i-1])
                break;
        }
        if(i != sortedArr.length)
            return sortedArr[i];
        else
            return -1;
    }

    /*
    *快速排序
      1．先从数列中取出一个数作为基准数。
      2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
      3．再对左右区间重复第二步，直到各区间只有一个数。
     */
    void quickSort(int arr[], int start, int end)
    {
        if(start < end)//判断start是否等于end,如果等于则说明各区间只有一个数
        {
            int i = start;
            int j = end;
            int x = arr[start];//将start作为基准数
            while(i < j)//如果i=j,则结束
            {
                while(i < j && arr[j] >= x) // 从右向左找第一个小于x的数
                    j--;
                //此时,arr[j] < x,则令arr[i]=arr[j],且i向前移动一格
                if(i < j)
                    arr[i++] = arr[j];

                while(i < j && arr[i] < x)// 从左向右找第一个大于等于x的数
                    i++;
                //此时,arr[i] >= x,则令arr[j]=arr[i],且j向后移动一格
                if(i < j)
                    arr[j--] = arr[i];
            }
            //此时,arr[i]=arr[j]=x,且比x大的数全在它的右边，小于或等于它的数全在其左边。下面则再对其左右区间重复这个步骤
            arr[i] = x;
            quickSort(arr,start,i-1);//对其左边区间重复上述操作
            quickSort(arr,i+1,end);//对其右边区间重复上述操作
        }
    }

    public static void main(String[] args) {

        int[] arr = {2,4,1,4,5,6,1};
        Test t = new Test();
        t.quickSort(arr,0,6);
        int dupValue = t.duplicate(arr);
    }
}

思路2

另一个简单的解决思路是哈希表。可以从头到尾按顺序扫描数组的每个数字，每次扫描，先判断该数字是否在哈希表中，如果存在，则该数为重复的数，如果不存在，则把该数字添加到哈希表中。这个算法的时间复杂度是$O(n)$，但是它使用了哈希表，所以空间复杂度是$O(n)$。这是一种以空间换时间的算法。下面是利用利用哈希表解决数组中重复的数字的Java程序：

package TempFile;
import java.util.HashSet;
import java.util.Set;

/**
 * Created by 余沾.
 */
public class Test {

    /*
     * 利用哈希表求出数组中重复的数字
     */
    int duplicate(int arr[])
    {
        Set set = new HashSet<Integer>();
        int i;
        for(i = 0;i < arr.length;i++)
        {
            if(arr[i] < 0 || arr[i] >= arr.length)
                throw new IllegalArgumentException("数组不合法");
        }
        for(i = 0;i < arr.length;i++)
        {
            if(set.contains(arr[i]))
                break;
            else
                set.add(arr[i]);
        }
        if(i != arr.length)
            return arr[i];
        else
            return -1;
    }

    public static void main(String[] args) {

        int[] arr = {2,4,1,4,5,6,1};
        Test t = new Test();
        t.quickSort(arr,0,6);
        int dupValue = t.duplicate(arr);
    }
}

思路3

前面的算法都没有很理想，理想的算法是时间复杂度为$O(n)$，空间复杂度为$O(1)$。注意到，数组中的数字都在0~n-1的范围内，所以，如果数组中没有重复的数，那么，当数组排序后，数字i将出现在下标为i的位置。由于数组中有重复的数字，有些位置可能存在多个数字，同时，有些位置可能没有数字。所以，我们可以利用这个思路高效解决这个问题。现在我们重排这个数组，从头到尾扫描每个数字，当扫描到下标为i的数字时，首先比较这个数字(记为m)是不是等于i。如果是，则接着扫描下一个数字；如果不是，则再拿它和第m个数字进行比较。如果它和第m个数字相等，就找到了一个重复的数字（该数字在下标为i和m的位置都出现了）；如果它和第m个数字不相等，就把第i个数字和第m个数字交换，把m放到属于它的位置。接下来再重复这个比较、交换的过程。下面则为该思路的Java实现程序：

package TempFile;

/**
 * Created by 余沾.
 */
public class Test {

    /*
     * 利用数组中的数只能在0~n-1解决问题
     */
    int duplicate(int arr[])
    {
        int i;
        for(i = 0;i < arr.length;i++)
        {
            if(arr[i] < 0 || arr[i] >= arr.length)
                throw new IllegalArgumentException("数组不合法");
        }
        for(i = 0;i < arr.length;i++)
        {
          while(arr[i] != i)
          {
              if(arr[i] == arr[arr[i]])//有重复的数
              {
                  return arr[i];
              }
              //如果arr[i]的值与arr中下标为arr[i]的值不相等,则互换两个值
              int temp = arr[i];
              arr[i] = arr[temp];
              arr[temp] = temp;
          }
        }
        return -1;
    }

    public static void main(String[] args) {

        int[] arr = {2,4,1,4,5,6,1};
        Test t = new Test();
        int dupValue = t.duplicate(arr);
    }
}

由于代码中有一个两重循环，但每个数字最多只要交换两次就能找到属于它自己的位置，因此总的时间复杂度是$O(n)$。另外，所有的操作步骤都是在输入数组上进行的，不需要额外分配内存，因此空间复杂度为$O(1)$。