Find Second largest number in array at most n+log₂(n)−2 comparisons [closed]

Answer 1

the problem is: let's say, in comparison level 1, the algorithm need to be remember all the array element because largest is not yet known, then, second, finally, third. by keep tracking these element via assignment will invoke additional value assignment and later when the largest is known, you need also consider the tracking back. As the result, it will not be significantly faster than simple 2N-2 Comparison algorithm. Moreover, because the code is more complicated, you need also think about potential debugging time.
eg: in PHP, RUNNING time for comparison vs value assignment roughly is :Comparison: (11-19) to value assignment: 16.

Answer 2

nlogn implementation

      public class Test {
           public static void main(String...args){
              int arr[] = new int[]{1,2,2,3,3,4,9,5, 100 , 101, 1, 2, 1000, 102, 2,2,2};
              System.out.println(getMax(arr, 0, 16));
           }

        public static Holder getMax(int[] arr, int start, int end){
           if (start == end)
             return new Holder(arr[start], Integer.MIN_VALUE);
        else {
          int mid = ( start + end ) / 2;
          Holder l = getMax(arr, start, mid);
          Holder r = getMax(arr, mid + 1, end);

          if (l.compareTo(r) > 0 )
            return new Holder(l.high(), r.high() > l.low() ? r.high() : l.low());
          else
            return new Holder(r.high(), l.high() > r.low() ? l.high(): r.low());
        }
      }

    static class Holder implements Comparable<Holder> {
      private int low, high;
      public Holder(int r, int l){low = l; high = r;}

    public String toString(){
      return String.format("Max: %d, SecMax: %d", high, low);
    }

    public int compareTo(Holder data){
      if (high == data.high)
        return 0;

      if (high > data.high)
        return 1;
      else
        return -1;
    }

    public int high(){
      return high;
    }
    public int low(){
      return low;
    }
  }

}

Answer 3

public static int FindSecondLargest(int[] input)
        {
            Dictionary<int, List<int>> dictWinnerLoser = new Dictionary<int, List<int>>();//Keeps track of loosers with winners
            List<int> lstWinners = null;
            List<int> lstLoosers = null;

            int winner = 0;
            int looser = 0;

            while (input.Count() > 1)//Runs till we get max in the array
            {
                lstWinners = new List<int>();//Keeps track of winners of each run, as we have to run with winners of each run till we get one winner

                for (int i = 0; i < input.Count() - 1; i += 2)
                {
                    if (input[i] > input[i + 1])
                    {
                        winner = input[i];
                        looser = input[i + 1];
                    }
                    else
                    {
                        winner = input[i + 1];
                        looser = input[i];
                    }

                    lstWinners.Add(winner);


                    if (!dictWinnerLoser.ContainsKey(winner))
                    {
                        lstLoosers = new List<int>();
                        lstLoosers.Add(looser);
                        dictWinnerLoser.Add(winner, lstLoosers);
                    }
                    else
                    {
                        lstLoosers = dictWinnerLoser[winner];
                        lstLoosers.Add(looser);
                        dictWinnerLoser[winner] = lstLoosers;
                    }
                }

                input = lstWinners.ToArray();//run the loop again with winners
            }

            List<int> loosersOfWinner = dictWinnerLoser[input[0]];//Gives all the elemetns who lost to max element of array, input array now has only one element which is actually the max of the array

            winner = 0;

            for (int i = 0; i < loosersOfWinner.Count(); i++)//Now max in the lossers of winner will give second largest
            {
                if (winner < loosersOfWinner[i])
                {
                    winner = loosersOfWinner[i];
                }
            }

            return winner;
        }

Answer 4

I have written the python code for this problem. And the code has all the necessary explanation in the comments.

# idea : each element is compared to other elements during 
# array_max exploration (n-1 comparison)
#  during this exploration, a list is stored as follows:
#     list=[k,value,a,b,c,d....]
# where k is # of elements with which 'value' is compared during the search for array_max.
# and a,b,c,d are the compared elements.
# so to find the second largest element we need to search 
# array_max in the list where 
# value=array_max. and at max k will be log(n). 


def getmax(l,r,a):
    
    if l<r:
        mid=(r+l)//2

       #list of compared_elements with max_value from the left sub- 
       #part
        comparedleft=getmax(l,mid,a)

        #list of compared_elements with max_value from the right
        #sub-part  
        comparedright=getmax(mid+1,r,a) 


        #comparedleft[1]=max_value of the left sub-part to be 
        #compared with other sub part's 
        # max_value(comparedright[1])
        #increment the k value
        #append the new element with which the value has been 
        #compared
        #return the list which contains max_value for this sub-part at 
        #'value'.
        #remember this list contains the elements with which value 
        #has been compared to.
       
        if comparedleft[1]>comparedright[1]: 
            comparedleft[0]+=1               
            comparedleft.append(comparedright[1]) 
            return comparedleft              
        
        else:                               #if max_value is in right sub-part
            comparedright[0]+=1
            comparedright.append(comparedleft[1])
            return comparedright

    #if len(subpart)==1. Generating list to store 
    #compared_elements (with a[l](an element from array))
    else:                  
        compared=[1,int(a[l])]  
        return compared
        
        
def secondmax(a):
    if len(a)==2:       
        if a[0]>a[1]:
            return a[1]
        else:
            return a[0];
        
    list1=getmax(0,len(a)-1,a)       # n-1 comparison
    list2=getmax(2,list1[0],list1)   # log(n)-1 comparison because 
                                                         # list will contain log(n) element 
                                                         # from [2:k]
    return list2[1]                             # return the max_value of 
                                                        # list1[2:k]


list1=input("enter the array = ").split()
if len(list1)==1:
    print("give array with more than 2 elements")
else:
    c=secondmax(list1)
    print(c)

Answer 5

In Python2.7: The following code works at O(nlog log n) for the extra sort. Any optimizations?

def secondLargest(testList):
    secondList = []
    # Iterate through the list
    while(len(testList) > 1):
        left = testList[0::2]
        right = testList[1::2]

        if (len(testList) % 2 == 1):
            right.append(0)

        myzip = zip(left,right)
        mymax = [ max(list(val)) for val in myzip ]
        myzip.sort()
        secondMax = [x for x in myzip[-1] if x != max(mymax)][0]

        if (secondMax != 0 ):
            secondList.append(secondMax)
        testList = mymax

    return max(secondList)