/// <summary> /// Insertion after a node. /// </summary> /// <param name="searchNodeValue">Node containing value.</param> /// <param name="newNodeValue">New node value.</param> public void InsertionAfterANode(T searchNodeValue, T newNodeValue) { //start node check if (StartNode == null) { return; } //Get the reference of the node contain value. var referenceNode = GetNode(searchNodeValue); //if the node with data found . if (referenceNode == null) { return; } //create the node . //Connect new node with the next node of the reference node. var newNode = new SingleLinkListNode <T>(newNodeValue) { Link = referenceNode.Link }; //reset the link between reference node and new node . referenceNode.Link = newNode; }
/// <summary> /// Delete the last node . /// </summary> public void DeleteLastNode() { if (StartNode == null) { return; } //Go to the one node before the last node . var predecessorNodeOfLastNode = GetReferenceToThePredecessorOfLastNode(); //Only one node exist . if (StartNode.Link == null) { //Remove that node . StartNode = null; return; } //Find predecessor of last node. if (predecessorNodeOfLastNode == null) { return; } //Remove last node . predecessorNodeOfLastNode.Link = null; }
/// <summary> /// Delete node with value . /// </summary> /// <param name="searchNodeValue"></param> public void DeleteNodeWithValue(T searchNodeValue) { //Check node . var desiredNode = GetNode(searchNodeValue); //null check. if (desiredNode == null) { return; } //check start node. if (desiredNode == StartNode) { StartNode = StartNode.Link; } //Get predecessor of last node . desiredNode = GetPredecessorNode(searchNodeValue); //null check. if (desiredNode == null) { return; } //Remove that node . desiredNode.Link = desiredNode.Link.Link; }
/// <summary> /// Insert a new node at position . /// </summary> /// <param name="position">Position in the list.</param> /// <param name="withInfo">Info part of the node.</param> public void InsertANewNodeAtPosition(int position, T withInfo) { //Get the reference of the predecessor node of the position . var referenceNode = GetPredecessorNodeAtPosition(position); //if the node with data found . if (referenceNode == null) { return; } //When reference node is not the start node . if (referenceNode != StartNode) { //create the node . //Connect new node with the next node of the reference node. var newNode = new SingleLinkListNode <T>(withInfo) { Link = referenceNode.Link }; //reset the link between reference node and new node . referenceNode.Link = newNode; } else { //Insert node at the beginning of the node . InsertionAtTheBeginning(withInfo); } }
/// <summary> /// Insert a node in an empty list . /// </summary> /// <param name="data"></param> public void InsertionInAnEmptyList(T data) { //create a new node . var node = new SingleLinkListNode <T>(data) { Link = null }; //it should be pointed by start node . StartNode = node; }
/// <summary> /// Insertion before a node. /// </summary> /// <param name="searchNodeValue">Node containing value.</param> /// <param name="newNodeValue">New node value.</param> public void InsertionBeforeANode(T searchNodeValue, T newNodeValue) { //start node check if (StartNode == null) { return; } //Get the reference of the predecessor node that contain value. var referenceNode = GetPredecessorNode(searchNodeValue); //if the node with data found . if (referenceNode == null) { return; } //Reference node is not a start node . if (referenceNode != StartNode) { //create the node . //Connect new node with the next node of the reference node. var newNode = new SingleLinkListNode <T>(newNodeValue) { Link = referenceNode.Link }; //reset the link between reference node and new node . referenceNode.Link = newNode; } //A reference node can be a start node in both condition . //Either searched value present in start node or. //second node contain the searched value . else { { // Reference node is a start node nad it contains the searched value. if (referenceNode.Info.Equals(searchNodeValue)) { InsertionAtTheBeginning(newNodeValue); } else { //create the node . //Connect new node with the next node of the reference node. var newNode = new SingleLinkListNode <T>(newNodeValue) { Link = referenceNode.Link }; //reset the link between reference node and new node . referenceNode.Link = newNode; } } } }
/// <summary> /// Delete first node . /// </summary> public void DeleteFirstNode() { //Check start node. if (StartNode == null) { return; } //2nd node . var secondNode = StartNode.Link; //let start node point it . StartNode = secondNode; }
/// <summary> /// Insert a node at the beginning . /// </summary> /// <typeparam name="T"></typeparam> /// <param name="data"></param> public void InsertionAtTheBeginning(T data) { //Check start. if (StartNode == null) { InsertionInAnEmptyList(data); } else { //create node . //link new node with the first node of the list . //first node is pointed by the start . var node = new SingleLinkListNode <T>(data) { Link = StartNode }; //Now start node should point to the new node . StartNode = node; } }
private void singlelinklist_Click(object sender, EventArgs e) { SingleLinkList list = new SingleLinkList(); list.InsertNodeAtBegining(1); list.InsertNodeAfter(3, 1); list.InsertNodeBefore(2, 3); list.InsertNodeAtEnd(4); list.InsertNodeAtEnd(5); list.InsertNodeAfter(6, 5); list.DeleteNode(3); list.Traverse(); list.TraverseBackward(); //Make list circular SingleLinkListNode second = list.Find(2); SingleLinkListNode node = list.Find(6); node.link = second; list.IsListCircular(); }
/// <summary> /// Single linked list Constructor . /// </summary> public SingleLinkedList() { //Set up start node to null . StartNode = null; }