# Analysis of run time complexity

#### Tags: java, time-complexity

I need some help below I have some code I created for an assignment. I am having a hard time figuring out the time complexity of this algorithm. I looked at it and believe the O-notation is 0(n) and the function is `F(n)= 4 + 2n`. But I think that is incorrect.

```/**
*mostOften method
*/

static int mostOften(int array[] , int n){

//Array to be sorted in ascending order
Arrays.sort(array);

//counts number of max occurrences in the array
int maxO = 1;

//Keeps track of the integer at Array[i].
int result = array;

//variable to count occurrences
int count = 1;

/**
*loop passes through array in linear motion and compares index at i and index at
* i - 1. For every possible outcome count and maxO are incremented accordingly.
*/
for(int i = 1 ; i < n ; i++){

//If integers are the same increment count.
if (array[i] == array[i - 1]){
count++;
}//close if statement

// else if integers are not the same
else{

//if count is larger thatn maxO that integer is the highers occurrence
if (count > maxO){

//count is now maxO
maxO = count;

//replaces result with integers with highest occurrence.
result = array[i - 1];
}//close if statement

//reset count to 1.
count = 1;

}//close else statement

}//close for loop

//@returns int data type
return result;

}//close mostOften method
```