//here's a singly linked list program with functions. However, I don't kbow how to add function #7 wherein
//the position of the maximum number in the list should be displayed.. :(

import java.util.Scanner;

class Node
{
    protected int data;
    protected Node link;
    protected int next_num;

    public Node()
    {
        link = null;
        data = 0;
    }    
    public Node(int d,Node n)
    {
        data = d;
        link = n;
    }    
    public void setLink(Node n)
    {
        link = n;
    }    
    public void setData(int d)
    {
        data = d;
    }    
    public Node getLink()
    {
        return link;
    }    
    public int getData()
    {
        return data;
    }
    public int next()
    {

        return next_num;
    }


}

class linkedList
{
    protected Node start;
    protected Node end ;
    public int size ;
    public int largest;
    public int ctr;

    public linkedList()
    {
        start = null;
        end = null;
        size = 0;
    }
    public int getLargest(){

        largest=start.getData();
        Node next=start.getLink();
        for(ctr=0;ctr<size;ctr++){
            if(largest<next.getData()){
            largest=next.getData();
            }
        next=next.getLink();
        }
        return ctr;
    }

    public boolean isEmpty()
    {
        return start == null;
    }
    public int getSize()
    {
        return size;
    }

    public void insertAtStart(int val)
    {
        Node nptr = new Node(val, null);    
        size++ ;    
        if(start == null) 
        {
            start = nptr;
            end = start;
        }
        else 
        {
            nptr.setLink(start);
            start = nptr;
        }
    }
    public void insertAtEnd(int val)
    {
        Node nptr = new Node(val,null);    
        size++ ;    
        if(start == null) 
        {
            start = nptr;
            end = start;
        }
        else 
        {
            end.setLink(nptr);
            end = nptr;
        }
    }
    public void insertAtPos(int val , int pos)
    {
        Node nptr = new Node(val, null);                
        Node ptr = start;
        pos = pos - 1 ;
        for (int i = 1; i < size; i++) 
        {
            if (i == pos) 
            {
                Node tmp = ptr.getLink() ;
                ptr.setLink(nptr);
                nptr.setLink(tmp);
                break;
            }
            ptr = ptr.getLink();
        }
        size++ ;
    }
    public void deleteAtPos(int pos)
    {        
        if (pos == 1) 
        {
            start = start.getLink();
            size--; 
            return ;
        }
        if (pos == size) 
        {
            Node s = start;
            Node t = start;
            while (s != end)
            {
                t = s;
                s = s.getLink();
            }
            end = t;
            end.setLink(null);
            size --;
            return;
        }
        Node ptr = start;
        pos = pos - 1 ;
        for (int i = 1; i < size - 1; i++) 
        {
            if (i == pos) 
            {
                Node tmp = ptr.getLink();
                tmp = tmp.getLink();
                ptr.setLink(tmp);
                break;
            }
            ptr = ptr.getLink();
        }
        size-- ;
    }    
    public void display()
    {
        System.out.print("\nSingly Linked List = ");
        if (size == 0) 
        {
            System.out.print("empty\n");
            return;
        }    
        if (start.getLink() == null) 
        {
            System.out.println(start.getData() );
            return;
        }
        Node ptr = start;
        System.out.print(start.getData()+ "->");
        ptr = start.getLink();
        while (ptr.getLink() != null)
        {
            System.out.print(ptr.getData()+ "->");
            ptr = ptr.getLink();
        }
        System.out.print(ptr.getData()+ "\n");
    }
}

public class SinglyLinkedList
{    
    public static void main(String[] args)
    {             
        Scanner scan = new Scanner(System.in);
        linkedList list = new linkedList(); 
        System.out.println("Singly Linked List Test\n");          
        char ch;
        do
        {
            System.out.println("\nSingly Linked List Operations\n");
            System.out.println("1. insert at begining");
            System.out.println("2. insert at end");
            System.out.println("3. insert at position");
            System.out.println("4. delete at position");
            System.out.println("5. check empty");
            System.out.println("6. get size");
            System.out.println("7. locate for the largest element.");            
            int choice = scan.nextInt();            
            switch (choice)
            {
            case 1 : 
                System.out.println("Enter integer element to insert");
                list.insertAtStart( scan.nextInt() );                     
                break;                          
            case 2 : 
                System.out.println("Enter integer element to insert");
                list.insertAtEnd( scan.nextInt() );                     
                break;                         
            case 3 : 
                System.out.println("Enter integer element to insert");
                int num = scan.nextInt() ;
                System.out.println("Enter position");
                int pos = scan.nextInt() ;
                if (pos <= 1 || pos > list.getSize() )
                    System.out.println("Invalid position\n");
                else
                    list.insertAtPos(num, pos);
                break;                                          
            case 4 : 
                System.out.println("Enter position");
                int p = scan.nextInt() ;
                if (p < 1 || p > list.getSize() )
                    System.out.println("Invalid position\n");
                else
                    list.deleteAtPos(p);
                break;
            case 5 : 
                System.out.println("Empty status = "+ list.isEmpty());
                break;                   
            case 6 : 
                System.out.println("Size = "+ list.getSize() +" \n");
                break; 
            case 7:
                System.out.println("position is at:"+list.getLargest());
                break;                         
             default : 
                System.out.println("Wrong Entry \n ");
                break;   
            }
            list.display();
            System.out.println("\nDo you want to continue (Type y or n) \n");
            ch = scan.next().charAt(0);                        
        } while (ch == 'Y'|| ch == 'y');               
    }
}

You already have a method to find the largest value. All you need is exactly that same logic, plus keep a count of the position as you loop. Each time you find a larger value, record the position where you found it.

i got it! :)

public int getLargest(){
        int loc=1;
        Node nptr=start.getLink();
        largest=start.getData();
        for(ctr=1;ctr<size;ctr++){
            if(largest<nptr.getData()){
            largest=nptr.getData();
            }else   
        nptr=nptr.getLink();
        }

        Node ptr=start.getLink();
        int t=start.getData();      
        for(int x=1;x<size;x++){
            if(t==largest)
            loc=x;
            t=ptr.getData();
            ptr=ptr.getLink(); 

            }
        return loc;
    }
    public int printLargest(){
        int loc=1;
        Node nptr=start.getLink();
        largest=start.getData();
        for(ctr=1;ctr<size;ctr++){
            if(largest<nptr.getData()){
            largest=nptr.getData();
            }else   
        nptr=nptr.getLink();
        }
        return largest;
    }

just have to add them in the case 7 option :)
in regards to the previous getLargest() method, the ctr was set to 0, which creates a nullPointerException and this time, I set it to 1 and it worked! :) :)

Edited 2 Years Ago by edamay.payay.9: grammar correction :)

This article has been dead for over six months. Start a new discussion instead.