15,998,008 members
0.00/5 (No votes)
See more:
We were tasked to apply the insertion sorting algorithm to an unsorted doubly circular linked list. I tried this algorithm given below;

Java
```<pre> public void insertSort(){
Node cur = head;
Node pointer; // this will hold the last position of where the sorting begins
Node handler = head;

do{
pointer = cur;
do{
if(cur.data < cur.prev.data){
handler.data = cur.data;
cur.data = cur.prev.data;
cur.prev.data = handler.data;

}
cur = cur.prev;
}while(cur != head);
cur = pointer;
cur = cur.next;
}while(cur != head);
}```

Above is the method to be called in sorting my doubly circular linked list.

What I have tried:

I tried inputting 10,9,8,7,6,5,4,3,2,1. But the output will be;

Java
`1-->1-->2-->3-->4-->5-->6-->7-->8-->9-->HEAD`

It looks like the first node on the unsorted list is removed and then the first node of the sorted list is doubled. Just like what happened. 10 is not on the output and 1 is doubled. I do not know where I went wrong since I tried this algorithm manually using pen and paper but everything works just fine.

Included below is the full code;

Java
```public class Circular {

private Node head;
private Node tail;

public Circular(){
this.head = null;
this.tail = null;
}

public void addNode(int data){
Node node = new Node(data);
if(head == null){
tail = node;
tail.prev = tail;
head = tail;
return;
}

node.prev = tail.prev;
node.next = tail;
tail.prev.next = node;
tail.prev = node;
head = tail;

}

public void printForward(){
Node node = head;

if(head != null){
do{
System.out.print(node.data + "-->");
node = node.next;
}while(node != head);
}
System.out.print("HEAD\n");
}

public void insertSort(){
Node cur = head;
Node pointer; // this will hold the last position of where the sorting begins
Node handler = head;

do{
pointer = cur;
do{
if(cur.data < cur.prev.data){
handler.data = cur.data;
cur.data = cur.prev.data;
cur.prev.data = handler.data;
System.out.print(cur.data + "<-->" + cur.next.data + "\n");
}
cur = cur.prev;
}while(cur != tail);
cur = pointer;
cur = cur.next;
}while(cur != head);
}
private class Node{
int data;
Node next;
Node prev;

public Node(int data){
this.data = data;
}
}
}
public class Main {
public static void main(String [] args){
Circular bubble = new Circular();
int num;
System.out.println("Enter 10 numbers in ascending order: ");
for(int i = 0; i < 10; i++){
Scanner scanner = new Scanner(System.in);
num = scanner.nextInt();
bubble.addNode(num);
}

bubble.printForward();
bubble.insertSort();
System.out.println("\n");
bubble.printForward();

}
}```
Posted
Updated 22-Sep-22 18:49pm

## Solution 1

Compiling does not mean your code is right! :laugh:
Think of the development process as writing an email: compiling successfully means that you wrote the email in the right language - English, rather than German for example - not that the email contained the message you wanted to send.

So now you enter the second stage of development (in reality it's the fourth or fifth, but you'll come to the earlier stages later): Testing and Debugging.

Start by looking at what it does do, and how that differs from what you wanted. This is important, because it give you information as to why it's doing it. For example, if a program is intended to let the user enter a number and it doubles it and prints the answer, then if the input / output was like this:
```Input   Expected output    Actual output
1            2                 1
2            4                 4
3            6                 9
4            8                16```
Then it's fairly obvious that the problem is with the bit which doubles it - it's not adding itself to itself, or multiplying it by 2, it's multiplying it by itself and returning the square of the input.
So with that, you can look at the code and it's obvious that it's somewhere here:
Java
```int Double(int value)
{
return value * value;
}```

Once you have an idea what might be going wrong, start using the debugger to find out why. Put a breakpoint on the first line of the method, and run your app. When it reaches the breakpoint, the debugger will stop, and hand control over to you. You can now run your code line-by-line (called "single stepping") and look at (or even change) variable contents as necessary (heck, you can even change the code and try again if you need to).
Think about what each line in the code should do before you execute it, and compare that to what it actually did when you use the "Step over" button to execute each line in turn. Did it do what you expect? If so, move on to the next line.
If not, why not? How does it differ?
Hopefully, that should help you locate which part of that code has a problem, and what the problem is.
This is a skill, and it's one which is well worth developing as it helps you in the real world as well as in development. And like all skills, it only improves by use!

Comments
Paul Lawrence Perez 23-Sep-22 1:45am
I will definitely do this. Thanks!!
OriginalGriff 23-Sep-22 2:14am
You're welcome!
Paul Lawrence Perez 23-Sep-22 3:24am
boy, this is actually my first time debugging and it is both fun and exhausting at the same time. I still haven't figured out why the first run through the loop is different from the latter tho. But I am progressing, thanks to you.
OriginalGriff 23-Sep-22 4:05am
It is fun, isn't it? Good way to learn as well.

On my ToDo list is the next in my "how to code for beginners" series of articles: debugging. Trouble is I'm trying to write some simple faulty code to use as an example and failing miserably to add bugs ... :sigh:
Paul Lawrence Perez 23-Sep-22 4:09am
That sounds amazing!! Tho intended failures surely sounds hard huehue. ANYWAYS I figured out my problem already! A value is passed down wrongly because of variables having the same data types which confuses the program regarding the assignment of values. I really thank you for introducing me to debugging!!!! aaaaaaa

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Top Experts
Last 24hrsThis month
 OriginalGriff 80 Wendelius 60 Richard Deeming 25 Pete O'Hanlon 25 Aggeliki Asimakopoulou 10
 OriginalGriff 511 Pete O'Hanlon 250 Richard Deeming 200 Dave Kreskowiak 133 CPallini 110

CodeProject, 20 Bay Street, 11th Floor Toronto, Ontario, Canada M5J 2N8 +1 (416) 849-8900