Can u rectify my mistakes ??

Question

well, i am very new to java programming, and have been into it for no more than 15 days ... i have a assignment, which i have worked as below. can anyone point my mistakes (how silly they might be) and if possible, tell me what is to be done to achieve the degree of correct code writing ?
the question is here
http://cs.albany.edu/~haas/cs310.html
(program3)
my code is as follows >
import java.util.*;
public class lp {
public double info;
public lp rest;
public lp(double info1, lp rest1)
public int(free_space)
public lp (data_memory)
info = info1;
rest = rest1;
public static void show_list(lp ptr1)
lp i;
for(i=ptr1;i != null;i = i.rest)
System.out.print(i.info + " ");
static lp read_list()
Scanner console = new Scanner(System.in);
lp answer = null;
double next_element;
next_element = console.nextDouble();
while(next_element >= 0)
answer = new lp(next_element, answer);
next_element = console.nextDouble();
return answer;
/* This function inserts a new element in an ordered lst, in the correct position.
* It returns a pointer to the new list. */
static lp insert(double new_num,lp ptr1)
/* If the list is empty, or the new element is <= the first element, put the\
* new element at the front. That is your answer. */
if((ptr1==null) || (new_num <= ptr1.info))
return new lp(new_num,ptr1);
else
/* At this point we know two things: the list is not empty, and the new
* element is > the first element. Move ptr2 up the list as long as this
* condition holds: there is an element after ptr2, and the new element is
* > the one after ptr2. */
lp ptr2 = ptr1;
while(ptr2.rest != null && new_num > data_memory[ptr1.rest])
ptr2 = ptr_memory[ptr2];
/* At this point we know that either there is no element after ptr2, or the
* new element is <= the one after ptr2. In either case, the new element goes
* after ptr2 */
ptr1.rest = new lp(new_num,ptr1);
/* We are not inserting the new element at the front, so ptr1 points to
* the answer. The value of ptr1 has not chnaged, but the list it points to
* has changed. */
return ptr1;
/* This function makes a copy of a linked list. The copy contains the same elements
* but they are in different places in the array. Changing the old linked
* list will not change the copy. */
public static int copy(lp ptr1)
/* This is the easy case. */
if(ptr1==null)
return null;
else
/* This is the first node of the copy. */
int ans = free_space();
/* It contains the same data as the first node of the old list. */
data_memory[ans] = ptr1.info;
/* This variable always holds the last node that we copied. Right now,
* its value is ans -- the node we copied in the last line. Note
* that the last node we copied has no successor. In order to
* give it a successor, we have to copy one more node! */
int last = ans;
/* This is the part of the old list that we still have to copy --
* everything except the first node. */
int old = ptr1.rest;
/* Keep copying until the uncopied part of the old list becomes empty. */
while(old!= null)
/* A new node for the copy. */
int new_node = free_space();
/* It contains the same data as the first node in the uncopied part of the
* old list. */
data_memory[new_node] = data_memory[old];
/* It is the successor to the last node the we copied. Remember that
* up till now, that last node had no successor.*/
ptr_memory[last] = new_node;
/* Now that we have finished copying, the new node becomes the last node
* that we copied. */
last = new_node;
/* We have copied one node, the uncopied part gets shorter by one. */
old = ptr_memory[old];
/* It is still true that the last node we copied has no successor. Since
* there is nothing left to copy, its successor is NULL_PTR. */
ptr_memory[last] = null;
/* We return the first node that we copied, because it is the first node
* of the copied list. */
return ans;
public static lp read_list2()
Scanner console = new Scanner(System.in);
return read_list3(console);
public static lp read_list3(Scanner scanner1)
double next;
next = scanner1.nextDouble();
if(next < 0)
return null;
else
return new lp(next,read_list3(scanner1));
// The function accepts number of elements from the user. It then asks for any element to entered
// it then inserts the element in the list and copies the same to the linked list to print the result
public static void main(String args[])
System.out.println("");
System.out.println("input list");
Scanner sc = new Scanner(System.in);
double new_num = sc.nextDouble();
double value = new_num();
lp list2 = new lp(7.0,new lp(5.0,new lp(6.0,null)));
show_list(list2);
list2 = read_list();
show_list(list2);
System.out.println("");
System.out.println("input number to insert");
System.out.println("");
System.out.println("new list");
System.out.println("");
System.out.println("copy");
Scanner sc = new Scanner(System.in);
insert((lp (new_num)),lp (ptr1));
copy (ptrl);
}

Answer 1

darshshinde wrote:
well, i am very new to java programming, and have been into it for no more than 15 days ... i have a assignment, which i have worked as below. can anyone point my mistakes (how silly they might be) and if possible, tell me what is to be done to achieve the degree of correct code writing ? You should review the Java tutorial available here http://java.sun.com/docs/books/tutorial/java/index.html
Then re-design your program so that it actually uses Objects which your's currently does not really. You should have an "ip" or whatever it is class and this class should have non-static methods that you call that operate on it.
It appears that the lp/Ip class is supposed to be some sort of linked list. I would work on the basics of this first.