CodeGo.net>创建一个非常简单的链表

我试图创建一个链表只是为了查看是否可以,但是我很难理解它。 有没有人有使用C#非常简单地实现链接列表的示例? 到目前为止,我发现的所有示例都过头了。

Shane asked 2019-11-08T17:13:34Z
17个解决方案
91 votes

链接列表的核心是一堆链接在一起的节点。

因此,您需要从一个简单的Node类开始:

public class Node {
    public Node next;
    public Object data;
}

然后,您的链表将具有一个代表该表头(开始)的节点作为成员:

public class LinkedList {
    private Node head;
}

然后,您需要通过添加方法将功能添加到列表中。 它们通常涉及沿所有节点的某种遍历。

public void printAllNodes() {
    Node current = head;
    while (current != null) 
    {
        Console.WriteLine(current.data);
        current = current.next;
    }
}

另外,插入新数据是另一种常见操作:

public void Add(Object data) {
    Node toAdd = new Node();
    toAdd.data = data;
    Node current = head;
    // traverse all nodes (see the print all nodes method for an example)
    current.next = toAdd;
}

这应该提供一个很好的起点。

jjnguy answered 2019-11-08T17:14:26Z
50 votes

根据@jjnguy所说的内容,并修复他的PrintAllNodes()中的错误,下面是完整的控制台应用程序示例:

public class Node
{
    public Node next;
    public Object data;
}

public class LinkedList
{
    private Node head;

    public void printAllNodes()
    {
        Node current = head;
        while (current != null)
        {
            Console.WriteLine(current.data);
            current = current.next;
        }
    }

    public void AddFirst(Object data)
    {
        Node toAdd = new Node();

        toAdd.data = data;
        toAdd.next = head;

        head = toAdd;
    }

    public void AddLast(Object data)
    {
        if (head == null)
        {
            head = new Node();

            head.data = data;
            head.next = null;
        }
        else
        {
            Node toAdd = new Node();
            toAdd.data = data;

            Node current = head;
            while (current.next != null)
            {
                current = current.next;
            }

            current.next = toAdd;
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Add First:");
        LinkedList myList1 = new LinkedList();

        myList1.AddFirst("Hello");
        myList1.AddFirst("Magical");
        myList1.AddFirst("World");
        myList1.printAllNodes();

        Console.WriteLine();

        Console.WriteLine("Add Last:");
        LinkedList myList2 = new LinkedList();

        myList2.AddLast("Hello");
        myList2.AddLast("Magical");
        myList2.AddLast("World");
        myList2.printAllNodes();

        Console.ReadLine();
    }
}
Dmytro answered 2019-11-08T17:14:50Z
12 votes

这个很好:

  namespace ConsoleApplication1
    {

    // T is the type of data stored in a particular instance of GenericList.
    public class GenericList<T>
    {
        private class Node
        {
            // Each node has a reference to the next node in the list.
            public Node Next;
            // Each node holds a value of type T.
            public T Data;
        }

        // The list is initially empty.
        private Node head = null;

        // Add a node at the beginning of the list with t as its data value.
        public void AddNode(T t)
        {
            Node newNode = new Node();
            newNode.Next = head;
            newNode.Data = t;
            head = newNode;
        }

        // The following method returns the data value stored in the last node in
        // the list. If the list is empty, the default value for type T is
        // returned.
        public T GetFirstAdded()
        {
            // The value of temp is returned as the value of the method. 
            // The following declaration initializes temp to the appropriate 
            // default value for type T. The default value is returned if the 
            // list is empty.
            T temp = default(T);

            Node current = head;
            while (current != null)
            {
                temp = current.Data;
                current = current.Next;
            }
            return temp;
        }
    }
}

测试代码:

static void Main(string[] args)
{
    // Test with a non-empty list of integers.
    GenericList<int> gll = new GenericList<int>();
    gll.AddNode(5);
    gll.AddNode(4);
    gll.AddNode(3);
    int intVal = gll.GetFirstAdded();
    // The following line displays 5.
    System.Console.WriteLine(intVal);
}

我在msdn上遇到过

nan answered 2019-11-08T17:15:23Z
5 votes

我是一个初学者,这对我有帮助:

class List
{
    private Element Root;
}

首先,您将创建包含所有方法的类List。然后创建Node-Class,我将其称为Element

class Element
{
    public int Value;
    public Element Next;
}

然后,您可以开始向List类添加方法。 例如,这是一个“添加”方法。

public void Add(int value)
{
    Element newElement = new Element();
    newElement.Value = value;

    Element rootCopy = Root;
    Root = newElement;
    newElement.Next = rootCopy;

    Console.WriteLine(newElement.Value);
}
Tim Kathete Stadler answered 2019-11-08T17:16:02Z
3 votes
public class Node
{
    private Object data;

    public Node next {get;set;}

    public Node(Object data)
    {
    this.data = data;
     }

}

 public class Linkedlist
  {
    Node head;

    public void Add(Node n) 
    {
    n.Next = this.Head;
    this.Head = n;
    }
 }

使用:

LinkedList sample = new LinkedList();
sample.add(new Node("first"));
sample.Add(new Node("second"))
ka-ja answered 2019-11-08T17:16:26Z
3 votes

这是一个带有IEnumerable和递归反向方法的方法,尽管它不比Reverse方法中的while循环快两个都是O(n):

   public class LinkedList<T> : IEnumerable
{
    private Node<T> _head = null;

    public Node<T> Add(T value)
    {
        var node = new Node<T> {Value = value};

        if (_head == null)
        {
            _head = node;
        }
        else
        {
            var current = _head;
            while (current.Next != null)
            {
                current = current.Next;
            }
            current.Next = node; //new head
        }

        return node;
    }

    public T Remove(Node<T> node)
    {
        if (_head == null)
            return node.Value;

        if (_head == node)
        {
            _head = _head.Next;
            node.Next = null;
            return node.Value;
        }

        var current = _head;
        while (current.Next != null)
        {
            if (current.Next == node)
            {
                current.Next = node.Next;
                return node.Value;
            }

            current = current.Next;
        }

        return node.Value;
    }

    public void Reverse()
    {
        Node<T> prev = null;
        var current = _head;

        if (current == null)
            return;

        while (current != null)
        {
            var next = current.Next;
            current.Next = prev;
            prev = current;
            current = next;
        }

        _head = prev;
    }

    public void ReverseRecurisve()
    {
        reverseRecurive(_head, null);
    }

    private void reverseRecurive(Node<T> current, Node<T> prev)
    {
        if (current.Next == null)
        {
            _head = current;
            _head.Next = prev;
            return;
        }

        var next = current.Next;
        current.Next = prev;
        reverseRecurive(next, current);
    }

    public IEnumerator<T> Enumerator()
    {
        var current = _head;
        while (current != null)
        {
            yield return current.Value;
            current = current.Next;
        }
    }

    public IEnumerator GetEnumerator()
    {
        return Enumerator();
    }
}

public class Node<T>
{
    public T Value { get; set; }
    public Node<T> Next { get; set; }
}
Brian Ogden answered 2019-11-08T17:16:50Z
2 votes

这是一个很好的实现。

  1. 它很短,但是实现了Add(x),Delete(x),Contain(x)和Print()。
  2. 添加到空列表或删除第一个元素时,它避免了特殊处理。尽管其他大多数示例在删除第一个元素时都进行了特殊处理。
  3. 该列表可以包含任何数据类型。

    using System;
    
    class Node<Type> : LinkedList<Type>
    {   // Why inherit from LinkedList? A: We need to use polymorphism.
        public Type value;
        public Node(Type value) { this.value = value; }
    }
    class LinkedList<Type>
    {   
        Node<Type> next;  // This member is treated as head in class LinkedList, but treated as next element in class Node.
        /// <summary> if x is in list, return previos pointer of x. (We can see any class variable as a pointer.)
        /// if not found, return the tail of the list. </summary>
        protected LinkedList<Type> Previos(Type x)
        {
            LinkedList<Type> p = this;      // point to head
            for (; p.next != null; p = p.next)
                if (p.next.value.Equals(x))
                    return p;               // find x, return the previos pointer.
            return p;                       // not found, p is the tail.
        }
        /// <summary> return value: true = success ; false = x not exist </summary>
        public bool Contain(Type x) { return Previos(x).next != null ? true : false; }
        /// <summary> return value: true = success ; false = fail to add. Because x already exist. 
        /// </summary> // why return value? If caller want to know the result, they don't need to call Contain(x) before, the action waste time.
        public bool Add(Type x)
        {
            LinkedList<Type> p = Previos(x);
            if (p.next != null)             // Find x already in list
                return false;
            p.next = new Node<Type>(x);
            return true;
        }
        /// <summary> return value: true = success ; false = x not exist </summary>
        public bool Delete(Type x)
        {
            LinkedList<Type> p = Previos(x);
            if (p.next == null)
                return false;
            //Node<Type> node = p.next;
            p.next = p.next.next;
            //node.Dispose();       // GC dispose automatically.
            return true;
        }
        public void Print()
        {
            Console.Write("List: ");
            for (Node<Type> node = next; node != null; node = node.next)
                Console.Write(node.value.ToString() + " ");
            Console.WriteLine();
        }
    }
    class Test
    {
        static void Main()
        {
            LinkedList<int> LL = new LinkedList<int>();
            if (!LL.Contain(0)) // Empty list
                Console.WriteLine("0 is not exist.");
            LL.Print();
            LL.Add(0);      // Add to empty list
            LL.Add(1); LL.Add(2); // attach to tail
            LL.Add(2);      // duplicate add, 2 is tail.
            if (LL.Contain(0))// Find existed element which is head
                Console.WriteLine("0 is exist.");
            LL.Print();
            LL.Delete(0);   // Delete head
            LL.Delete(2);   // Delete tail
            if (!LL.Delete(0)) // Delete non-exist element
                Console.WriteLine("0 is not exist.");
            LL.Print();
            Console.ReadLine();
        }
    }
    

顺便说一下[http://www.functionx.com/csharp1/examples/linkedlist.htm]有一些问题:

  1. 只有1个元素时,Delete()将失败。(在“ Head.Next = Current.Next;”行引发异常,因为Current为空。)
  2. 删除第一个元素时,Delete(position)将失败,换句话说,调用Delete(0)将失败。
peizon answered 2019-11-08T17:18:05Z
2 votes

我摘录了《 Joseph Albahari和Ben Albahari的C#6.0简而言之》一书的摘录

这是使用LinkedList的演示:

var tune = new LinkedList<string>();
tune.AddFirst ("do"); // do
tune.AddLast ("so"); // do - so
tune.AddAfter (tune.First, "re"); // do - re- so
tune.AddAfter (tune.First.Next, "mi"); // do - re - mi- so
tune.AddBefore (tune.Last, "fa"); // do - re - mi - fa- so
tune.RemoveFirst(); // re - mi - fa - so
tune.RemoveLast(); // re - mi - fa
LinkedListNode<string> miNode = tune.Find ("mi");
tune.Remove (miNode); // re - fa
tune.AddFirst (miNode); // mi- re - fa
foreach (string s in tune) Console.WriteLine (s);
yogihosting answered 2019-11-08T17:18:37Z
1 votes
public class Node<T>
{
    public T item;
    public Node<T> next;
    public Node()
    {
        this.next = null;
    }
}


class LinkList<T>
{
    public Node<T> head { get; set; }
    public LinkList()
    {
        this.head = null;
    }


    public void AddAtHead(T item)
    {
        Node<T> newNode = new Node<T>();
        newNode.item = item;
        if (this.head == null)
        {
            this.head = newNode;
        }
        else
        {
            newNode.next = head;
            this.head = newNode;
        }
    }

    public void AddAtTail(T item)
    {
        Node<T> newNode = new Node<T>();
        newNode.item = item;
        if (this.head == null)
        {
            this.head = newNode;
        }
        else
        {
            Node<T> temp = this.head;
            while (temp.next != null)
            {
                temp = temp.next;
            }
            temp.next = newNode;
        }
    }

    public void DeleteNode(T item)
    {
        if (this.head.item.Equals(item))
        {
            head = head.next;
        }
        else
        {
            Node<T> temp = head;
            Node<T> tempPre = head;
            bool matched = false;
            while (!(matched = temp.item.Equals(item)) && temp.next != null)
            {
                tempPre = temp;
                temp = temp.next;
            }
            if (matched)
            {
                tempPre.next = temp.next;
            }
            else
            {
                Console.WriteLine("Value not found!");
            }
        }
    }

    public bool searchNode(T item)
    {
        Node<T> temp = this.head;
        bool matched = false;
        while (!(matched = temp.item.Equals(item)) && temp.next != null)
        {
            temp = temp.next;
        }
        return matched;

    }
    public void DisplayList()
    {
        Console.WriteLine("Displaying List!");
        Node<T> temp = this.head;
        while (temp != null)
        {
            Console.WriteLine(temp.item);
            temp = temp.next;
        }
    }

}
Ahmed answered 2019-11-08T17:18:55Z
0 votes
public class DynamicLinkedList
{

    private class Node
    {
        private object element;
        private Node next;

        public object Element
        {
            get { return this.element; }
            set { this.element = value; }
        }

        public Node Next
        {
            get { return this.next; }
            set { this.next = value; }
        }

        public Node(object element, Node prevNode)
        {
            this.element = element;
            prevNode.next = this;
        }

        public Node(object element)
        {
            this.element = element;
            next = null;
        }
    }

    private Node head;
    private Node tail;
    private int count;

    public DynamicLinkedList()
    {
        this.head = null;
        this.tail = null;
        this.count = 0;
    }

    public void AddAtLastPosition(object element)
    {
        if (head == null)
        {
            head = new Node(element);
            tail = head;
        }
        else
        {
            Node newNode = new Node(element, tail);
            tail = newNode;
        }

        count++;
    }

    public object GetLastElement()
    {
        object lastElement = null;
        Node currentNode = head;

        while (currentNode != null)
        {
            lastElement = currentNode.Element;
            currentNode = currentNode.Next;
        }

        return lastElement;
    }

}

测试:

static void Main(string[] args)
{
    DynamicLinkedList list = new DynamicLinkedList();
    list.AddAtLastPosition(1);
    list.AddAtLastPosition(2);
    list.AddAtLastPosition(3);
    list.AddAtLastPosition(4);
    list.AddAtLastPosition(5);

    object lastElement = list.GetLastElement();
    Console.WriteLine(lastElement);
}
Nojka7a answered 2019-11-08T17:19:19Z
0 votes

Dmytro做得很好,但是这里是一个更简洁的版本。

class Program
{
    static void Main(string[] args)
    {
        LinkedList linkedList = new LinkedList(1);

        linkedList.Add(2);
        linkedList.Add(3);
        linkedList.Add(4);

        linkedList.AddFirst(0);

        linkedList.Print();            
    }
}

public class Node
{
    public Node(Node next, Object value)
    {
        this.next = next;
        this.value = value;
    }

    public Node next;
    public Object value;
}

public class LinkedList
{
    public Node head;

    public LinkedList(Object initial)
    {
        head = new Node(null, initial);
    }

    public void AddFirst(Object value)
    {
        head = new Node(head, value);            
    }

    public void Add(Object value)
    {
        Node current = head;

        while (current.next != null)
        {
            current = current.next;
        }

        current.next = new Node(null, value);
    }

    public void Print()
    {
        Node current = head;

        while (current != null)
        {
            Console.WriteLine(current.value);
            current = current.next;
        }
    }
}
Erik Bergstedt answered 2019-11-08T17:19:43Z
0 votes

添加一个Node类。
然后添加一个链接列表类以实现链接列表
添加测试类以执行链接列表

namespace LinkedListProject
{
    public class Node
    {
        public Node next;
        public object data;
    }

    public class MyLinkedList
    {
        Node head;
        public Node AddNodes(Object data)
        {
            Node node = new Node();

            if (node.next == null)
            {
                node.data = data;
                node.next = head;
                head = node;
            }
            else
            {
                while (node.next != null)
                    node = node.next;

                node.data = data;
                node.next = null;

            }
            return node;
        }

        public void printnodes()
        {
            Node current = head;
            while (current.next != null)
            {
                Console.WriteLine(current.data);
                current = current.next;
            }
            Console.WriteLine(current.data);
        }
    }


    [TestClass]
    public class LinkedListExample
    {
        MyLinkedList linkedlist = new MyLinkedList();
        [TestMethod]
        public void linkedlisttest()
        {
            linkedlist.AddNodes("hello");
            linkedlist.AddNodes("world");
            linkedlist.AddNodes("now");
            linkedlist.printnodes();
        }
    }
}
rshalucse answered 2019-11-08T17:20:23Z
0 votes

简单的c#程序,通过操作AddItemStart,AddItemEnd,RemoveItemStart,RemoveItemEnd和DisplayAllItems实现单个链接列表

 using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Threading.Tasks;

    namespace SingleLinkedList
    {
        class Program
        {
            Node head;
            Node current;
            int counter = 0;
            public Program()
            {
                head = new Node();
                current = head;
            }
            public void AddStart(object data)
            {
                Node newnode = new Node();
                newnode.next = head.next;
                newnode.data = data;
                head.next = newnode;
                counter++;
            }
            public void AddEnd(object data)
            {
                Node newnode = new Node();
                newnode.data = data;
                current.next = newnode;
                current = newnode;
                counter++;
            }
            public void RemoveStart()
            {
                if (counter > 0)
                {
                    head.next = head.next.next;
                    counter--;
                }
                else
                {
                    Console.WriteLine("No element exist in this linked list.");
                }
            }
            public void RemoveEnd()
            {
                if (counter > 0)
                {
                    Node prevNode = new Node();
                    Node cur = head;
                    while (cur.next != null)
                    {
                        prevNode = cur;
                        cur = cur.next;
                    }
                    prevNode.next = null;
                }
                else
                {
                    Console.WriteLine("No element exist in this linked list.");
                }
            }
            public void Display()
            {
                Console.Write("Head ->");
                Node curr = head;
                while (curr.next != null)
                {
                    curr = curr.next;
                    Console.WriteLine(curr.data.ToString());
                }
            }
            public class Node
            {
                public object data;
                public Node next;
            }
            static void Main(string[] args)
            {
                Program p = new Program();
                p.AddEnd(2);
                p.AddStart(1);
                p.AddStart(0);
                p.AddEnd(3);
                p.Display();
                p.RemoveStart();
                Console.WriteLine("Removed node from Start");
                p.Display();
                Console.WriteLine("Removed node from End");
                p.RemoveEnd();
                p.Display();
                Console.ReadKey();
            }
        }
    }
Jaydeep Shil answered 2019-11-08T17:20:47Z
0 votes

所选答案没有迭代器; 它是更基本的,但可能没有用。

这是一个带有迭代器/枚举器的对象。 我的实现基于Sedgewick的书包。 参见[http://algs4.cs.princeton.edu/13stacks/Bag.java.html]

void Main()
{
    var b = new Bag<string>();
    b.Add("bike");
    b.Add("erasmus");
    b.Add("kumquat");
    b.Add("beaver");
    b.Add("racecar");
    b.Add("barnacle");

    foreach (var thing in b)
    {
        Console.WriteLine(thing);
    }
}

// Define other methods and classes here

public class Bag<T> : IEnumerable<T>
{
    public Node<T> first;// first node in list

    public class Node<T>
    {
        public T item;
        public Node<T> next;

        public Node(T item)
        {
            this.item = item;
        }
    }


    public void Add(T item)
    {
        Node<T> oldFirst = first;
        first = new Node<T>(item);
        first.next = oldFirst;
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public IEnumerator<T> GetEnumerator()
    {
        return new BagEnumerator<T>(this);
    }

    public class BagEnumerator<V> : IEnumerator<T>
    {
        private Node<T> _head;
        private Bag<T> _bag;
        private Node<T> _curNode;


        public BagEnumerator(Bag<T> bag)
        {

            _bag = bag;
            _head = bag.first;
            _curNode = default(Node<T>);

        }

        public T Current
        {
            get { return _curNode.item; }
        }


        object IEnumerator.Current
        {
            get { return Current; }
        }

        public bool MoveNext()
        {
            if (_curNode == null)
            {
                _curNode = _head;
                if (_curNode == null)
                return false;
                return true;
            }
            if (_curNode.next == null)
            return false;
            else
            {
                _curNode = _curNode.next;
                return true;
            }

        }

        public void Reset()
        {
            _curNode = default(Node<T>); ;
        }


        public void Dispose()
        {
        }
    }
}
jacoblambert answered 2019-11-08T17:21:21Z
0 votes

我创建了以下具有许多功能的LinkedList代码。 它可以在CodeBase github public repo下公开使用。

类:AddFirst(data), AddFirst(node), AddLast(data), RemoveLast(), AddAfter(node, data), RemoveBefore(node), Find(node), Remove(foundNode), Print(LinkedList)Last

吸气剂和吸气剂:AddFirst(data), AddFirst(node), AddLast(data), RemoveLast(), AddAfter(node, data), RemoveBefore(node), Find(node), Remove(foundNode), Print(LinkedList)Last

职能:AddFirst(data), AddFirst(node), AddLast(data), RemoveLast(), AddAfter(node, data), RemoveBefore(node), Find(node), Remove(foundNode), Print(LinkedList)

using System;
using System.Collections.Generic;

namespace Codebase
{
    public class Node
    {
        public object Data { get; set; }
        public Node Next { get; set; }

        public Node()
        {
        }

        public Node(object Data, Node Next = null)
        {
            this.Data = Data;
            this.Next = Next;
        }
    }

    public class LinkedList
    {
        private Node Head;
        public Node First
        {
            get => Head;
            set
            {
                First.Data = value.Data;
                First.Next = value.Next;
            }
        }

        public Node Last
        {
            get
            {
                Node p = Head;
                //Based partially on https://en.wikipedia.org/wiki/Linked_list
                while (p.Next != null)
                    p = p.Next; //traverse the list until p is the last node.The last node always points to NULL.

                return p;
            }
            set
            {
                Last.Data = value.Data;
                Last.Next = value.Next;
            }
        }

        public void AddFirst(Object data, bool verbose = true)
        {
            Head = new Node(data, Head);
            if (verbose) Print();
        }

        public void AddFirst(Node node, bool verbose = true)
        {
            node.Next = Head;
            Head = node;
            if (verbose) Print();
        }

        public void AddLast(Object data, bool Verbose = true)
        {
            Last.Next = new Node(data);
            if (Verbose) Print();
        }

        public Node RemoveFirst(bool verbose = true)
        {
            Node temp = First;
            Head = First.Next;
            if (verbose) Print();
            return temp;
        }

        public Node RemoveLast(bool verbose = true)
        {
            Node p = Head;
            Node temp = Last;

            while (p.Next != temp)
                p = p.Next;

            p.Next = null;
            if (verbose) Print();

            return temp;
        }

        public void AddAfter(Node node, object data, bool verbose = true)
        {
            Node temp = new Node(data);
            temp.Next = node.Next;
            node.Next = temp;

            if (verbose) Print();
        }

        public void AddBefore(Node node, object data, bool verbose = true)
        {
            Node temp = new Node(data);

            Node p = Head;

            while (p.Next != node) //Finding the node before
            {
                p = p.Next;
            }

            temp.Next = p.Next; //same as  = node
            p.Next = temp;

            if (verbose) Print();
        }

        public Node Find(object data)
        {
            Node p = Head;

            while (p != null)
            {
                if (p.Data == data)
                    return p;

                p = p.Next;
            }
            return null;
        }

        public void Remove(Node node, bool verbose = true)
        {
            Node p = Head;

            while (p.Next != node)
            {
                p = p.Next;
            }

            p.Next = node.Next;
            if (verbose) Print();
        }

        public void Print()
        {
            Node p = Head;
            while (p != null) //LinkedList iterator
            {
                Console.Write(p.Data + " ");
                p = p.Next; //traverse the list until p is the last node.The last node always points to NULL.
            }
            Console.WriteLine();
        }
    }
}

当她使用Microsoft内置的LinkedList和LinkedListNode回答问题时,使用@yogihosting答案,您可以获得相同的结果:

using System;
using System.Collections.Generic;
using Codebase;

namespace Cmd
{
    static class Program
    {
        static void Main(string[] args)
        {
            var tune = new LinkedList(); //Using custom code instead of the built-in LinkedList<T>
            tune.AddFirst("do"); // do
            tune.AddLast("so"); // do - so
            tune.AddAfter(tune.First, "re"); // do - re- so
            tune.AddAfter(tune.First.Next, "mi"); // do - re - mi- so
            tune.AddBefore(tune.Last, "fa"); // do - re - mi - fa- so
            tune.RemoveFirst(); // re - mi - fa - so
            tune.RemoveLast(); // re - mi - fa
            Node miNode = tune.Find("mi"); //Using custom code instead of the built in LinkedListNode
            tune.Remove(miNode); // re - fa
            tune.AddFirst(miNode); // mi- re - fa
 }
}
Shadi Namrouti answered 2019-11-08T17:22:15Z
-1 votes

我有一个双向链表,可以用作堆栈或队列。 如果您看一下代码并考虑它的功能以及如何执行,我敢打赌,您将了解它的所有内容。 我很抱歉,但是不知何故我无法在此处添加完整代码,所以我在这里是链表的链接(解决方案中也有二叉树):[https://github.com/szabeast/LinkedList_and_BinaryTree]

Szabolcs Fekete answered 2019-11-08T17:22:40Z
-2 votes

链表是基于节点的数据结构。 每个节点都设计有两个部分(数据和节点引用)。实际上,数据始终存储在数据部分(也许是原始数据类型,例如Int,Float等,我们也可以存储用户定义的数据类型,例如对象引用),并且类似 节点引用也应包含对下一个节点的引用,如果没有下一个节点,则链结束。

该链将持续到没有下一个节点参考点的任何节点。

请从我的技术博客中找到源代码-[http://www.algonuts.info/linked-list-program-in-java.html]

package info.algonuts;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

class LLNode {
    int nodeValue;
    LLNode childNode;

    public LLNode(int nodeValue) {
        this.nodeValue = nodeValue;
        this.childNode = null;
    }
}

class LLCompute {
    private static LLNode temp;
    private static LLNode previousNode;
    private static LLNode newNode;
    private static LLNode headNode;

    public static void add(int nodeValue) {
        newNode = new LLNode(nodeValue);
        temp = headNode;
        previousNode = temp;
        if(temp != null)
        {   compute();  }
        else
        {   headNode = newNode; }   //Set headNode
    }

    private static void compute() {
        if(newNode.nodeValue < temp.nodeValue) {    //Sorting - Ascending Order
            newNode.childNode = temp;
            if(temp == headNode) 
            {   headNode = newNode; }
            else if(previousNode != null) 
            {   previousNode.childNode = newNode;   }
        }
        else
        {
            if(temp.childNode == null)
            {   temp.childNode = newNode;   }
            else
            {
                previousNode = temp;
                temp = temp.childNode;
                compute();
            }
        }
    }

    public static void display() {
        temp = headNode;
        while(temp != null) {
            System.out.print(temp.nodeValue+" ");
            temp = temp.childNode;
        }
    }
}

public class LinkedList {
    //Entry Point
    public static void main(String[] args) {
        //First Set Input Values
        List <Integer> firstIntList = new ArrayList <Integer>(Arrays.asList(50,20,59,78,90,3,20,40,98));   
        Iterator<Integer> ptr  = firstIntList.iterator();
        while(ptr.hasNext()) 
        {   LLCompute.add(ptr.next());  }
        System.out.println("Sort with first Set Values");
        LLCompute.display();
        System.out.println("\n");

        //Second Set Input Values
        List <Integer> secondIntList = new ArrayList <Integer>(Arrays.asList(1,5,8,100,91));   
        ptr  = secondIntList.iterator();
        while(ptr.hasNext()) 
        {   LLCompute.add(ptr.next());  }
        System.out.println("Sort with first & Second Set Values");
        LLCompute.display();
        System.out.println();
    }
}
Karthikeyan Moorthy answered 2019-11-08T17:23:20Z
translate from https://stackoverflow.com:/questions/3823848/creating-a-very-simple-linked-list