内层的循环逐个的取元素与外层传入的元素进行比較。假设全部元素都匹配成功。则返回1，否则返回0。

#include<iostream>

//假设arr2是arr1的子集，则返回1.
bool isSubset(int arr1[], int arr2[], int numArr1, int numArr2)
{
  int i = 0;
  int j = 0;
  for (i = 0; i < numArr2; i++)
  {
    for (j = 0; j < numArr1; j++)
    {
      if (arr2[i] == arr1[j])
        break;
    }

    //假设上面的内层循环没有break, 则说明arr2不是arr1的子集
    if (j == numArr1)
      return 0;
  }

  //假设运行到这里，说明arr2是arr1的子集
  return 1;
}

int main()
{
  int arr1[] = { 11, 1, 13, 21, 3, 7 };
  int arr2[] = { 11, 3, 7, 1 };

  int numArr1 = sizeof(arr1) / sizeof(arr1[0]);
  int numArr2 = sizeof(arr2) / sizeof(arr2[0]);

  if (isSubset(arr1, arr2, numArr1, numArr2))
    std::cout<<"arr2[] is subset of arr1[]";
  else
    std::cout<<"arr2[] is not a subset of arr1[]";

  return 0;
}

方法2 (使用排序和二分搜索)

#include <iostream>

//函数声明 。
两个辅助函数，用于推断子集。

void quickSort(int *arr, int si, int ei);
int binarySearch(int arr[], int low, int high, int x);

// 假设arr2[]是arr1[]的一个子集，则返回1
bool isSubset(int arr1[], int arr2[], int numArr1, int numArr2)
{
    int i = 0;

    quickSort(arr1, 0, numArr1-1);
    for (i=0; i<numArr2; i++)
    {
        if (binarySearch(arr1, 0, numArr1-1, arr2[i]) == -1)
           return 0;
    }

    //假设运行到了这里。说明arr2是arr1的子集
    return 1;
}

//---------辅助函数begin--------

//标准的二分查找函数
int binarySearch(int arr[], int low, int high, int x)
{
  if(high >= low)
  {
    int mid = (low + high)/2;  //或者low + (high - low)/2;

    /*
     * 检測arr[mid]是否为第一次遇到x。
     * 当x满足以下情况的一种时，则证明是第一次遇到x：
     (1) (mid == 0) && (arr[mid] == x)
     (2) (arr[mid-1] < x) && (arr[mid] == x)
     */
    if(( mid == 0 || arr[mid-1] < x) && (arr[mid] == x))
      return mid;
    else if(x > arr[mid])
      return binarySearch(arr, (mid + 1), high, x);
    else
      return binarySearch(arr, low, (mid -1), x);
  }
 return -1;
}

template<typename type>
void exchange(type *a, type *b)
{
    type temp;
    temp = *a;
    *a   = *b;
    *b   = temp;
}

int partition(int A[], int si, int ei)
{
    int x = A[ei];
    int i = (si - 1);
    int j;

    for (j = si; j <= ei - 1; j++)
    {
        if(A[j] <= x)
        {
            i++;
            exchange(&A[i], &A[j]);
        }
    }
    exchange (&A[i + 1], &A[ei]);
    return (i + 1);
}

/*
实现高速排序的函数
A[]：须要排序的数组
si：Starting index
ei：Ending index
*/
void quickSort(int A[], int si, int ei)
{
    int pi;    //Partitioning index
    if(si < ei)
    {
        pi = partition(A, si, ei);
        quickSort(A, si, pi - 1);
        quickSort(A, pi + 1, ei);
    }
}
//---------辅助函数end--------

int main()
{
    int arr1[] = {11, 1, 13, 21, 3, 7};
    int arr2[] = {11, 3, 7, 1};

    int numArr1 = sizeof(arr1)/sizeof(arr1[0]);
    int numArr2 = sizeof(arr2)/sizeof(arr2[0]);

    if(isSubset(arr1, arr2, numArr1, numArr2))
      std::cout<<"arr2[] is subset of arr1[]";
    else
      std::cout<<"arr2[] is not a subset of arr1[]";

    return 0;
}

方法3 (使用排序和归并 )

//假设arr2是arr1的子集。则返回1
bool isSubset(int arr1[], int arr2[], int m, int n)
{
    int i = 0, j = 0;

    if(m < n)
       return 0;

    quickSort(arr1, 0, m-1);
    quickSort(arr2, 0, n-1);
    while( i < n && j < m )
    {
        if( arr1[j] <arr2[i] )
            j++;
        else if( arr1[j] == arr2[i] )
        {
            j++;
            i++;
        }
        else if( arr1[j] > arr2[i] )
            return 0;
    }

    if( i < n )
        return 0;
    else
        return 1;
}