你怎么知道一个阵列在另一个阵列中重复多少次？

Question

For example, if you were given {1,2} as the small array and {1,2,3,4,1,2,1,3} as the big one, then it would return 2.

This is probably horribly incorrect:

public static int timesOccur(int[] small, int big[]) {
    int sum= 0; 
    for (int i=0; i<small.length; i++){
        int currentSum = 0;
        for (int j=0; j<big.length; j++){       
            if (small[i] == big[j]){
                currentSum ++;
            }   
            sum= currentSum ;
        }
    }
    return sum;
}

Answer 1

As @AndyTurner mentioned, your task can be reduced to the set of well-known string matching algorithms.

As I can understand you want solution faster than O(n * m).

There are two main approaches. First involves preprocessing text (long array), second involves preprocessing search pattern (small array).

1. Preprocessing text. By this I mean creating suffix array or LCP from your longer array. Having this data structure constructed you can perform a binary search to find your your substring. The most efficient time you can achieve is O(n) to build LCP and O(m + log n) to perform the search. So overall time is O(n + m).

2. Preprocessing pattern. This means construction DFA from the pattern. Having DFA constructed it takes one traversal of the string (long array) to find all occurrences of substring (linear time). The hardest part here is to construct the DFA. Knuth-Morris-Pratt does this in O(m) time, so overall algorithm running time will be O(m + n). Actually KMP algorithm is most probably the best available solution for this task in terms of efficiency and implementation complexity. Check @JuanLopes 's answer for concrete implementation.

Also you can consider optimized bruteforce, for example Boyer-Moore , it is good for practical cases, but it has O(n * m) running time in worst case.

UPD:

In case you don't need fast approaches, I corrected your code from description:

    public static int timesOccur(int[] small, int big[]) {
        int sum = 0;
        for (int i = 0; i < big.length - small.length + 1; i++) {
            int j = 0;
            while (j < small.length && small[j] == big[i + j]) {
                j++;
            }
            if (j == small.length) {
                sum++;
            }
        }
        return sum;
    }

Pay attention on the inner while loop. It stops as soon as elements don't match. It's important optimization, as it makes running time almost linear for best cases.

upd2: inner loop explanation.

The purpose of inner loop is to find out if smaller array matches bigger array starting from position i . To perform that check index j is iterated from 0 to length of smaller array, comparing the element j of the smaller array with the corresponding element i + j of the bigger array. Loop proceeds when both conditions are true at the same time: j < small.length and corresponding elements of two arrays match.

So loop stops in two situations:

1. j < small.length is false . This means that j==small.length . Also it means that for all j=0..small.length-1 elements of the two arrays matched (otherwise loop would break earlier, see (2) below).
2. small[j] == big[i + j] is false . This means that match was not found. In this case loop will break before j reaches small.length

After the loop it's sufficient to check whether j==small.length to know which condition made loop to stop and hence know whether match was found or not for current position i .

Answer 2

This is a simple subarray matching problem. In Java you can use Collections.indexOfSublist , but you would have to box all the integers in your array. An option is to implement your own array matching algorithm. There are several options, most string searching algorithms can be adapted to this task.

Here is an optimized version based on the KMP algorithm . In the worst case it will be O(n + m), which is better than the trivial algorithm. But it has the downside of requiring extra space to compute the failure function ( F ).

public class Main {
    public static class KMP {
        private final int F[];
        private final int[] needle;

        public KMP(int[] needle) {
            this.needle = needle;
            this.F = new int[needle.length + 1];

            F[0] = 0;
            F[1] = 0;
            int i = 1, j = 0;
            while (i < needle.length) {
                if (needle[i] == needle[j])
                    F[++i] = ++j;
                else if (j == 0)
                    F[++i] = 0;
                else
                    j = F[j];
            }
        }

        public int countAt(int[] haystack) {
            int count = 0;
            int i = 0, j = 0;
            int n = haystack.length, m = needle.length;

            while (i - j <= n - m) {
                while (j < m) {
                    if (needle[j] == haystack[i]) {
                        i++;
                        j++;
                    } else break;
                }
                if (j == m) count++;
                else if (j == 0) i++;
                j = F[j];
            }
            return count;
        }
    }

    public static void main(String[] args) {
        System.out.println(new KMP(new int[]{1, 2}).countAt(new int[]{1, 2, 3, 4, 1, 2, 1, 3}));
        System.out.println(new KMP(new int[]{1, 1}).countAt(new int[]{1, 1, 1}));
    }
}

Answer 3

Rather than posting a solution I'll provide some hints to get your moving.

It's worth breaking the problem down into smaller pieces, in general your algorithm should look like:

for each position in the big array
     check if the small array matches that position
         if it does, increment your counter

The smaller piece is then checking if the small array matches a given position

first check if there's enough room to fit the smaller array
    if not then the arrays don't match
otherwise for each position in the smaller array
    check if the values in the arrays match
        if not then the arrays don't match
if you get to the end of the smaller array and they have all matched
    then the arrays match

Answer 4

Though not thoroughly tested I believe this is a solution to your problem. I would highly recommend using Sprinters pseudocode to try and figure this out yourself before using this.

public static void main(String[] args)
{
    int[] smallArray = {1,1};
    int[] bigArray = {1,1,1};
    int sum = 0;

    for(int i = 0; i < bigArray.length; i++)
    {
        boolean flag = true;
        if(bigArray[i] == smallArray[0])
        {
            for(int x = 0; x < smallArray.length; x++)
            {
                if(i + x >= bigArray.length)
                    flag = false;
                else if(bigArray[i + x] != smallArray[x])
                    flag = false;

            }

            if(flag)
                sum += 1;
        }
    }

    System.out.println(sum);

}

}