Linked list implementation along with unit test
1
$begingroup$
I want to see how other people think of my code, so here it goes. This is my first time writing a unit test. I'm wondering if there needs to be more tests for the LinkedList class and also if I'm writing them correctly.
I've made the Node class public so I can use it for a binary tree implementation later.
namespace DataStructuresAndAlgorithms.DataStructures
{
public class Node<T>
{
public T Data { get; set; }
public Node<T> Next { get; set; }
public Node<T> Previous { get; set; }
public Node() { }
public Node(T t)
{
Data = t;
}
}
}
Implementation
using System;
using System.Collections.Generic;
namespace DataStructuresAndAlgorithms.DataStructures
{
public class LinkedList<T>
{
public Node<T> Head { get; private set; }
public Node<T> Tail { get; private set; }
public LinkedList(Node<T> node)
{
Head = node;
Tail = node;
}
public void AddToFirst(Node<T> toAdd)
{
toAdd.Next = Head;
Head = toAdd;
}
public void AddToLast(Node<T> toAdd)
{
Tail.Next = toAdd;
Tail = toAdd;
}
public void RemoveFirst()
{
Head = Head.Next;
}
public void RemoveLast()
{
var pointer = Head;
while (pointer.Next != Tail)
{
pointer = pointer.Next;
}
// pointer is now before Tail
Tail = pointer;
Tail.Next = null;
}
public IEnumerator<Node<T>> GetEnumerator()
{
var pointer = Head;
while (pointer != null)
{
yield return pointer;
pointer = pointer.Next;
}
}
}
}
Unit Test
using System;
using Xunit;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.DataStructures.Tests
{
public class LinkedListTest
{
[Fact]
public void AddToFirst_Node_Should_Become_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(45));
// Act
var nodeToAdd = new Node<int>(67);
myLinkedList.AddToFirst(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
Assert.Equal(45, theNode.Next.Data);
}
[Fact]
public void AddToLast_Node_Should_Become_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(35));
// Act
var nodeToAdd = new Node<int>(14);
myLinkedList.AddToLast(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
}
[Fact]
public void RemoveFirst_Next_Node_Should_Be_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveFirst();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node1);
Assert.Equal(node1, myLinkedList.Head);
}
[Fact]
public void RemoveLast_Next_Node_Should_Be_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveLast();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node2);
Assert.Equal(node2, myLinkedList.Tail);
}
public static Node<T> GetNodeFromList<T>(LinkedList<T> someLinkedList, Node<T> someNode) where T : struct
{
using (var itr = someLinkedList.GetEnumerator())
{
while (itr.Current != someNode)
{
itr.MoveNext();
}
return itr.Current;
}
}
}
}
Presentation
using System;
using System.Collections;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.Presentation.Console
{
class Program
{
static void Main(string args)
{
RunNode();
System.Console.WriteLine();
RunLinkedList();
}
static void RunNode()
{
System.Console.WriteLine("Running the Node class");
System.Console.WriteLine("----------------------");
var myNode = new Node<int>(32);
System.Console.WriteLine(myNode.Data);
}
static void RunLinkedList()
{
System.Console.WriteLine("Running the LinkedList class");
System.Console.WriteLine("----------------------------");
var myLinkedList = new LinkedList<int>(new Node<int>(99));
myLinkedList.AddToFirst(new Node<int>(56));
myLinkedList.AddToFirst(new Node<int>(23));
myLinkedList.AddToFirst(new Node<int>(33));
myLinkedList.AddToLast(new Node<int>(8888));
myLinkedList.RemoveLast();
myLinkedList.RemoveFirst();
System.Console.WriteLine("HEAD = " + myLinkedList.Head.Data);
System.Console.WriteLine("TAIL = " + myLinkedList.Tail.Data);
using (var linkedListEnumerator = myLinkedList.GetEnumerator())
{
while (linkedListEnumerator.MoveNext())
{
System.Console.WriteLine(linkedListEnumerator.Current.Data);
}
}
}
}
}
```
c# linked-list
asked 1 hour ago
feature_creepfeature_creep
62
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
$endgroup$
add a comment |
1
$begingroup$
I want to see how other people think of my code, so here it goes. This is my first time writing a unit test. I'm wondering if there needs to be more tests for the LinkedList class and also if I'm writing them correctly.
I've made the Node class public so I can use it for a binary tree implementation later.
namespace DataStructuresAndAlgorithms.DataStructures
{
public class Node<T>
{
public T Data { get; set; }
public Node<T> Next { get; set; }
public Node<T> Previous { get; set; }
public Node() { }
public Node(T t)
{
Data = t;
}
}
}
Implementation
using System;
using System.Collections.Generic;
namespace DataStructuresAndAlgorithms.DataStructures
{
public class LinkedList<T>
{
public Node<T> Head { get; private set; }
public Node<T> Tail { get; private set; }
public LinkedList(Node<T> node)
{
Head = node;
Tail = node;
}
public void AddToFirst(Node<T> toAdd)
{
toAdd.Next = Head;
Head = toAdd;
}
public void AddToLast(Node<T> toAdd)
{
Tail.Next = toAdd;
Tail = toAdd;
}
public void RemoveFirst()
{
Head = Head.Next;
}
public void RemoveLast()
{
var pointer = Head;
while (pointer.Next != Tail)
{
pointer = pointer.Next;
}
// pointer is now before Tail
Tail = pointer;
Tail.Next = null;
}
public IEnumerator<Node<T>> GetEnumerator()
{
var pointer = Head;
while (pointer != null)
{
yield return pointer;
pointer = pointer.Next;
}
}
}
}
Unit Test
using System;
using Xunit;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.DataStructures.Tests
{
public class LinkedListTest
{
[Fact]
public void AddToFirst_Node_Should_Become_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(45));
// Act
var nodeToAdd = new Node<int>(67);
myLinkedList.AddToFirst(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
Assert.Equal(45, theNode.Next.Data);
}
[Fact]
public void AddToLast_Node_Should_Become_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(35));
// Act
var nodeToAdd = new Node<int>(14);
myLinkedList.AddToLast(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
}
[Fact]
public void RemoveFirst_Next_Node_Should_Be_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveFirst();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node1);
Assert.Equal(node1, myLinkedList.Head);
}
[Fact]
public void RemoveLast_Next_Node_Should_Be_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveLast();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node2);
Assert.Equal(node2, myLinkedList.Tail);
}
public static Node<T> GetNodeFromList<T>(LinkedList<T> someLinkedList, Node<T> someNode) where T : struct
{
using (var itr = someLinkedList.GetEnumerator())
{
while (itr.Current != someNode)
{
itr.MoveNext();
}
return itr.Current;
}
}
}
}
Presentation
using System;
using System.Collections;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.Presentation.Console
{
class Program
{
static void Main(string args)
{
RunNode();
System.Console.WriteLine();
RunLinkedList();
}
static void RunNode()
{
System.Console.WriteLine("Running the Node class");
System.Console.WriteLine("----------------------");
var myNode = new Node<int>(32);
System.Console.WriteLine(myNode.Data);
}
static void RunLinkedList()
{
System.Console.WriteLine("Running the LinkedList class");
System.Console.WriteLine("----------------------------");
var myLinkedList = new LinkedList<int>(new Node<int>(99));
myLinkedList.AddToFirst(new Node<int>(56));
myLinkedList.AddToFirst(new Node<int>(23));
myLinkedList.AddToFirst(new Node<int>(33));
myLinkedList.AddToLast(new Node<int>(8888));
myLinkedList.RemoveLast();
myLinkedList.RemoveFirst();
System.Console.WriteLine("HEAD = " + myLinkedList.Head.Data);
System.Console.WriteLine("TAIL = " + myLinkedList.Tail.Data);
using (var linkedListEnumerator = myLinkedList.GetEnumerator())
{
while (linkedListEnumerator.MoveNext())
{
System.Console.WriteLine(linkedListEnumerator.Current.Data);
}
}
}
}
}
```
c# linked-list
asked 1 hour ago
feature_creepfeature_creep
62
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
$endgroup$
add a comment |
1
1
1
$begingroup$
I want to see how other people think of my code, so here it goes. This is my first time writing a unit test. I'm wondering if there needs to be more tests for the LinkedList class and also if I'm writing them correctly.
I've made the Node class public so I can use it for a binary tree implementation later.
namespace DataStructuresAndAlgorithms.DataStructures
{
public class Node<T>
{
public T Data { get; set; }
public Node<T> Next { get; set; }
public Node<T> Previous { get; set; }
public Node() { }
public Node(T t)
{
Data = t;
}
}
}
Implementation
using System;
using System.Collections.Generic;
namespace DataStructuresAndAlgorithms.DataStructures
{
public class LinkedList<T>
{
public Node<T> Head { get; private set; }
public Node<T> Tail { get; private set; }
public LinkedList(Node<T> node)
{
Head = node;
Tail = node;
}
public void AddToFirst(Node<T> toAdd)
{
toAdd.Next = Head;
Head = toAdd;
}
public void AddToLast(Node<T> toAdd)
{
Tail.Next = toAdd;
Tail = toAdd;
}
public void RemoveFirst()
{
Head = Head.Next;
}
public void RemoveLast()
{
var pointer = Head;
while (pointer.Next != Tail)
{
pointer = pointer.Next;
}
// pointer is now before Tail
Tail = pointer;
Tail.Next = null;
}
public IEnumerator<Node<T>> GetEnumerator()
{
var pointer = Head;
while (pointer != null)
{
yield return pointer;
pointer = pointer.Next;
}
}
}
}
Unit Test
using System;
using Xunit;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.DataStructures.Tests
{
public class LinkedListTest
{
[Fact]
public void AddToFirst_Node_Should_Become_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(45));
// Act
var nodeToAdd = new Node<int>(67);
myLinkedList.AddToFirst(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
Assert.Equal(45, theNode.Next.Data);
}
[Fact]
public void AddToLast_Node_Should_Become_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(35));
// Act
var nodeToAdd = new Node<int>(14);
myLinkedList.AddToLast(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
}
[Fact]
public void RemoveFirst_Next_Node_Should_Be_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveFirst();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node1);
Assert.Equal(node1, myLinkedList.Head);
}
[Fact]
public void RemoveLast_Next_Node_Should_Be_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveLast();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node2);
Assert.Equal(node2, myLinkedList.Tail);
}
public static Node<T> GetNodeFromList<T>(LinkedList<T> someLinkedList, Node<T> someNode) where T : struct
{
using (var itr = someLinkedList.GetEnumerator())
{
while (itr.Current != someNode)
{
itr.MoveNext();
}
return itr.Current;
}
}
}
}
Presentation
using System;
using System.Collections;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.Presentation.Console
{
class Program
{
static void Main(string args)
{
RunNode();
System.Console.WriteLine();
RunLinkedList();
}
static void RunNode()
{
System.Console.WriteLine("Running the Node class");
System.Console.WriteLine("----------------------");
var myNode = new Node<int>(32);
System.Console.WriteLine(myNode.Data);
}
static void RunLinkedList()
{
System.Console.WriteLine("Running the LinkedList class");
System.Console.WriteLine("----------------------------");
var myLinkedList = new LinkedList<int>(new Node<int>(99));
myLinkedList.AddToFirst(new Node<int>(56));
myLinkedList.AddToFirst(new Node<int>(23));
myLinkedList.AddToFirst(new Node<int>(33));
myLinkedList.AddToLast(new Node<int>(8888));
myLinkedList.RemoveLast();
myLinkedList.RemoveFirst();
System.Console.WriteLine("HEAD = " + myLinkedList.Head.Data);
System.Console.WriteLine("TAIL = " + myLinkedList.Tail.Data);
using (var linkedListEnumerator = myLinkedList.GetEnumerator())
{
while (linkedListEnumerator.MoveNext())
{
System.Console.WriteLine(linkedListEnumerator.Current.Data);
}
}
}
}
}
```
c# linked-list
asked 1 hour ago
feature_creepfeature_creep
62
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
$endgroup$
I want to see how other people think of my code, so here it goes. This is my first time writing a unit test. I'm wondering if there needs to be more tests for the LinkedList class and also if I'm writing them correctly.
I've made the Node class public so I can use it for a binary tree implementation later.
namespace DataStructuresAndAlgorithms.DataStructures
{
public class Node<T>
{
public T Data { get; set; }
public Node<T> Next { get; set; }
public Node<T> Previous { get; set; }
public Node() { }
public Node(T t)
{
Data = t;
}
}
}
Implementation
using System;
using System.Collections.Generic;
namespace DataStructuresAndAlgorithms.DataStructures
{
public class LinkedList<T>
{
public Node<T> Head { get; private set; }
public Node<T> Tail { get; private set; }
public LinkedList(Node<T> node)
{
Head = node;
Tail = node;
}
public void AddToFirst(Node<T> toAdd)
{
toAdd.Next = Head;
Head = toAdd;
}
public void AddToLast(Node<T> toAdd)
{
Tail.Next = toAdd;
Tail = toAdd;
}
public void RemoveFirst()
{
Head = Head.Next;
}
public void RemoveLast()
{
var pointer = Head;
while (pointer.Next != Tail)
{
pointer = pointer.Next;
}
// pointer is now before Tail
Tail = pointer;
Tail.Next = null;
}
public IEnumerator<Node<T>> GetEnumerator()
{
var pointer = Head;
while (pointer != null)
{
yield return pointer;
pointer = pointer.Next;
}
}
}
}
Unit Test
using System;
using Xunit;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.DataStructures.Tests
{
public class LinkedListTest
{
[Fact]
public void AddToFirst_Node_Should_Become_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(45));
// Act
var nodeToAdd = new Node<int>(67);
myLinkedList.AddToFirst(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
Assert.Equal(45, theNode.Next.Data);
}
[Fact]
public void AddToLast_Node_Should_Become_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(35));
// Act
var nodeToAdd = new Node<int>(14);
myLinkedList.AddToLast(nodeToAdd);
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, nodeToAdd);
Assert.Equal(nodeToAdd, theNode);
}
[Fact]
public void RemoveFirst_Next_Node_Should_Be_Head()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveFirst();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node1);
Assert.Equal(node1, myLinkedList.Head);
}
[Fact]
public void RemoveLast_Next_Node_Should_Be_Tail()
{
// Arrange
var myLinkedList = new LinkedList<int>(new Node<int>(777));
var node1 = new Node<int>(1);
myLinkedList.AddToLast(node1);
var node2 = new Node<int>(2);
myLinkedList.AddToLast(node2);
var node3 = new Node<int>(3);
myLinkedList.AddToLast(node3);
// Act
myLinkedList.RemoveLast();
// Assert
var theNode = GetNodeFromList<int>(myLinkedList, node2);
Assert.Equal(node2, myLinkedList.Tail);
}
public static Node<T> GetNodeFromList<T>(LinkedList<T> someLinkedList, Node<T> someNode) where T : struct
{
using (var itr = someLinkedList.GetEnumerator())
{
while (itr.Current != someNode)
{
itr.MoveNext();
}
return itr.Current;
}
}
}
}
Presentation
using System;
using System.Collections;
using DataStructuresAndAlgorithms.DataStructures;
namespace DataStructuresAndAlgorithms.Presentation.Console
{
class Program
{
static void Main(string args)
{
RunNode();
System.Console.WriteLine();
RunLinkedList();
}
static void RunNode()
{
System.Console.WriteLine("Running the Node class");
System.Console.WriteLine("----------------------");
var myNode = new Node<int>(32);
System.Console.WriteLine(myNode.Data);
}
static void RunLinkedList()
{
System.Console.WriteLine("Running the LinkedList class");
System.Console.WriteLine("----------------------------");
var myLinkedList = new LinkedList<int>(new Node<int>(99));
myLinkedList.AddToFirst(new Node<int>(56));
myLinkedList.AddToFirst(new Node<int>(23));
myLinkedList.AddToFirst(new Node<int>(33));
myLinkedList.AddToLast(new Node<int>(8888));
myLinkedList.RemoveLast();
myLinkedList.RemoveFirst();
System.Console.WriteLine("HEAD = " + myLinkedList.Head.Data);
System.Console.WriteLine("TAIL = " + myLinkedList.Tail.Data);
using (var linkedListEnumerator = myLinkedList.GetEnumerator())
{
while (linkedListEnumerator.MoveNext())
{
System.Console.WriteLine(linkedListEnumerator.Current.Data);
}
}
}
}
}
```
c# linked-list
c# linked-list
asked 1 hour ago
feature_creepfeature_creep
62
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
asked 1 hour ago
feature_creepfeature_creep
62
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
asked 1 hour ago
feature_creepfeature_creep
62
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
asked 1 hour ago
feature_creepfeature_creep
62
asked 1 hour ago
feature_creepfeature_creep
62
62
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
New contributor
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
feature_creep is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
add a comment |
add a comment |
0
active
oldest
votes
Your Answer
StackExchange.ifUsing("editor", function () {
return StackExchange.using("mathjaxEditing", function () {
StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix) {
StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["\$", "\$"]]);
});
});
}, "mathjax-editing");
StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");
StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "196"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);
StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});
function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});
}
});
feature_creep is a new contributor. Be nice, and check out our Code of Conduct.
draft saved
draft discarded
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f216453%2flinked-list-implementation-along-with-unit-test%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
0
active
oldest
votes
0
active
oldest
votes
active
oldest
votes
active
oldest
votes
feature_creep is a new contributor. Be nice, and check out our Code of Conduct.
draft saved
draft discarded
feature_creep is a new contributor. Be nice, and check out our Code of Conduct.
feature_creep is a new contributor. Be nice, and check out our Code of Conduct.
feature_creep is a new contributor. Be nice, and check out our Code of Conduct.
Thanks for contributing an answer to Code Review Stack Exchange!
- Please be sure to answer the question. Provide details and share your research!
But avoid …
- Asking for help, clarification, or responding to other answers.
- Making statements based on opinion; back them up with references or personal experience.
Use MathJax to format equations. MathJax reference.
To learn more, see our tips on writing great answers.
draft saved
draft discarded
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f216453%2flinked-list-implementation-along-with-unit-test%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
