Skip to content
Related Articles

Related Articles

Java Program For Stock Buy Sell To Maximize Profit

View Discussion
Improve Article
Save Article
  • Difficulty Level : Basic
  • Last Updated : 24 Jul, 2022
View Discussion
Improve Article
Save Article

The cost of a stock on each day is given in an array, find the max profit that you can make by buying and selling in those days. For example, if the given array is {100, 180, 260, 310, 40, 535, 695}, the maximum profit can earned by buying on day 0, selling on day 3. Again buy on day 4 and sell on day 6. If the given array of prices is sorted in decreasing order, then profit cannot be earned at all.

Naive approach: A simple approach is to try buying the stocks and selling them on every single day when profitable and keep updating the maximum profit so far.

Below is the implementation of the above approach:

Java




// Java implementation of the approach
import java.util.*;
class GFG{
 
// Function to return the maximum profit
// that can be made after buying and
// selling the given stocks
static int maxProfit(int price[],
                     int start, int end)
{
    // If the stocks can't be bought
    if (end <= start)
        return 0;
 
    // Initialise the profit
    int profit = 0;
 
    // The day at which the stock
    // must be bought
    for (int i = start; i < end; i++)
    {
        // The day at which the
        // stock must be sold
        for (int j = i + 1; j <= end; j++)
        {
            // If buying the stock at ith day and
            // selling it at jth day is profitable
            if (price[j] > price[i])
            {
 
                // Update the current profit
                int curr_profit = price[j] - price[i] +
                                  maxProfit(price,
                                            start, i - 1) +
                                  maxProfit(price,
                                            j + 1, end);
 
                // Update the maximum profit so far
                profit = Math.max(profit,
                                  curr_profit);
            }
        }
    }
    return profit;
}
 
// Driver code
public static void main(String[] args)
{
    int price[] = {100, 180, 260, 310,
                   40, 535, 695};
    int n = price.length;
    System.out.print(maxProfit(
                     price, 0, n - 1));
}
}
// This code is contributed by PrinciRaj1992


Output:

865

Efficient approach: If we are allowed to buy and sell only once, then we can use following algorithm. Maximum difference between two elements. Here we are allowed to buy and sell multiple times. 
Following is the algorithm for this problem.  

  1. Find the local minima and store it as starting index. If not exists, return.
  2. Find the local maxima. and store it as an ending index. If we reach the end, set the end as the ending index.
  3. Update the solution (Increment count of buy-sell pairs)
  4. Repeat the above steps if the end is not reached.

Java




// Program to find best buying and
// selling days
import java.util.ArrayList;
 
// Solution structure
class Interval
{
    int buy, sell;
}
 
class StockBuySell
{
    // This function finds the buy sell
    // schedule for maximum profit
    void stockBuySell(int price[], int n)
    {
        // Prices must be given for at least
        // two days
        if (n == 1)
            return;
 
        int count = 0;
 
        // Solution array
        ArrayList<Interval> sol =
                  new ArrayList<Interval>();
 
        // Traverse through given price array
        int i = 0;
        while (i < n - 1)
        {
            // Find Local Minima. Note that the
            // limit is (n-2) as we are comparing
            // present element to the next element.
            while ((i < n - 1) &&
                   (price[i + 1] <= price[i]))
                i++;
 
            // If we reached the end, break as no
            // further solution possible
            if (i == n - 1)
                break;
 
            Interval e = new Interval();
            e.buy = i++;
            // Store the index of minima
 
            // Find Local Maxima.  Note that the
            // limit is (n-1) as we are comparing
            // to previous element
            while ((i < n) &&
                   (price[i] >= price[i - 1]))
                i++;
 
            // Store the index of maxima
            e.sell = i - 1;
            sol.add(e);
 
            // Increment number of buy/sell
            count++;
        }
 
        // print solution
        if (count == 0)
            System.out.println(
            "There is no day when buying the stock " +
            "will make profit");
        else
            for (int j = 0; j < count; j++)
                System.out.println(
                "Buy on day: " + sol.get(j).buy +
                "        " + "Sell on day : " +
                sol.get(j).sell);
 
        return;
    }
 
    // Driver code
    public static void main(String args[])
    {
        StockBuySell stock = new StockBuySell();
 
        // stock prices on consecutive days
        int price[] = {100, 180, 260,
                       310, 40, 535, 695};
        int n = price.length;
 
        // function call
        stock.stockBuySell(price, n);
    }
}
// This code is contributed by Mayank Jaiswal


Output:

Buy on day: 0     Sell on day: 3
Buy on day: 4     Sell on day: 6

Time Complexity: The outer loop runs till I become n-1. The inner two loops increment value of I in every iteration. So overall time complexity is O(n)

Auxiliary Space: O(1) since using constant variables

Valley Peak Approach:

In this approach, we just need to find the next greater element and subtract it from the current element so that the difference keeps increasing until we reach a minimum. If the sequence is a decreasing sequence so the maximum profit possible is 0.

Java




// Java program for the above approach
import java.io.*;
class GFG
{
    static int maxProfit(int prices[],
                         int size)
    {   
        // maxProfit adds up the difference
        // between adjacent elements if they
        // are in increasing order
        int maxProfit = 0;
     
        // The loop starts from 1 as its
        // comparing with the previous
        for (int i = 1; i < size; i++)
            if (prices[i] > prices[i - 1])
                maxProfit += prices[i] - prices[i - 1];
        return maxProfit;
    }
 
    // Driver code
    public static void main(String[] args)
    {   
        // stock prices on consecutive days
        int price[] = {100, 180, 260,
                       310, 40, 535, 695};
        int n = price.length;
 
        // function call
        System.out.println(maxProfit(price, n));
    }
}
// This code is contributed by rajsanghavi9.


Output:

865

Time Complexity: O(n)
Auxiliary Space: O(1)

This article is compiled by Ashish Anand and reviewed by the GeeksforGeeks team. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!