Java 从头开始创建LinkedList类
我们被指派从头开始创建一个LinkedList，但绝对没有任何阅读资料来指导我们完成这项导致偏头痛的任务。此外，所有在线内容似乎都只使用Java内置的LinkedList方法和其他东西。无论如何，当使用Java的默认内容时，链表是非常有意义的，但是从头开始创建链表毫无意义。假设我有Java 从头开始创建LinkedList类,java,data-structures,linked-list,append,Java,Data Structures,Linked List,Append,我们被指派从头开始创建一个LinkedList，但绝对没有任何阅读资料来指导我们完成这项导致偏头痛的任务。此外，所有在线内容似乎都只使用Java内置的LinkedList方法和其他东西。无论如何，当使用Java的默认内容时，链表是非常有意义的，但是从头开始创建链表毫无意义。假设我有 public class LinkedList { private LinkedList next; private final String word; // constructor publi
public class LinkedList {
private LinkedList next;
private final String word;
// constructor
public LinkedList(String word, LinkedList next) {
this.word = word;
this.next = next;
}
因此，神奇的是，我们有了一个链表。发生了什么事？我是如何创建这样的链表的？这是怎么回事？我应该编写一个append方法，将给定的
字符串单词这个this.next.Append(word);
如果您实际上正在构建一个真正的系统，那么是的，如果您需要的东西在标准库中可用，您通常只需要使用标准库中的东西。也就是说，不要认为这是一个毫无意义的练习。理解事物是如何工作的很好，理解链表是理解更复杂的数据结构的重要一步，其中许多数据结构在标准库中是不存在的 创建链表的方式与Java collections API创建链表的方式有一些不同。Collections API试图遵循更复杂的接口。在构建单链接列表时，Collections API链表也是双链接列表。你所做的更适合课堂作业 使用
LinkedListnullnext链接列表的示意图：
请注意，它是一个LinkedList
对象，指向一个单词（“Hello”）和一个包含2个元素的列表。由2个元素组成的列表有一个单词（“堆栈”）和一个由1个元素组成的列表。1个元素的列表有一个单词（“溢出”）和一个空列表（null
）。因此，您可以将next
视为恰好短一个元素的另一个列表
您可能需要添加另一个仅接受字符串的构造函数，并在null
旁边设置。这将用于创建一个单元素列表
要追加，请检查next
是否为null
。如果是，则创建一个新的单元素列表，并将next
设置为该列表
next = new LinkedList(word);
如果next不是null
，则改为附加到next
next.append(word);
这是递归方法，代码量最少。您可以将其转化为迭代解决方案，在Java*中效率更高，并且不会因为很长的列表而出现堆栈溢出的风险，但我猜您的任务不需要复杂度
*有些语言具有尾部调用消除，这是一种优化，允许语言实现将“尾部调用”（返回前最后一步对另一个函数的调用）转换为（有效地）goto。这使得此类代码完全避免使用堆栈，从而使其更安全（如果不使用堆栈，则不会溢出堆栈），并且通常效率更高。Scheme可能是最著名的具有此功能的语言示例。当然，对于编程N00B来说，链表有点让人困惑，很容易将其视为俄罗斯玩偶，因为这看起来就像是LinkedList对象中的LinkedList对象。但这是一个很难想象的触摸，相反，把它看成一台电脑
LinkedList=数据+下一个成员
如果next为NULL，则它是列表的最后一个成员
因此，由5名成员组成的LinkedList应该是：
LinkedList（数据1，LinkedList）（数据2，LinkedList（数据3，LinkedList）（数据4，LinkedList（数据5，NULLщщ））
但你可以简单地认为：
Data1->Data2->Data3->Data4->Data5->NULL
那么，我们如何找到这一切的结局呢？我们知道NULL是结尾，所以：
public void append(LinkedList myNextNode) {
LinkedList current = this; //Make a variable to store a pointer to this LinkedList
while (current.next != NULL) { //While we're not at the last node of the LinkedList
current = current.next; //Go further down the rabbit hole.
}
current.next = myNextNode; //Now we're at the end, so simply replace the NULL with another Linked List!
return; //and we're done!
}
当然，这是一个非常简单的代码，如果你给它一个循环链表，它将无限循环！但这是最基本的。您编写的代码不是，至少我不认识。对于此分配，您要创建两个类：
LinkNode
LinkedList
一个LinkNode
有一个成员字段用于它所包含的数据，还有一个LinkNode
引用到LinkedList
中的下一个LinkNode
。是的，它是一个自引用的数据结构。LinkedList
只有一个特殊的LinkNode
引用，它引用了列表中的第一项
在链接列表
中添加项目时，将遍历所有链接节点
，直到到达最后一个。此链接节点的下一步应为空。然后在此处构造一个新的LinkNode
，设置其值，并将其添加到LinkedList
public class LinkNode {
String data;
LinkNode next;
public LinkNode(String item) {
data = item;
}
}
public class LinkedList {
LinkNode head;
public LinkedList(String item) {
head = new LinkNode(item);
}
public void add(String item) {
//pseudo code: while next isn't null, walk the list
//once you reach the end, create a new LinkNode and add the item to it. Then
//set the last LinkNode's next to this new LinkNode
}
}
提示1：请阅读以下链接列表的说明：
提示2:LinkedList的Java实现是一个双链表。你的是一个单链表。这些算法并不直接适用
import java.util.Iterator;
import java.util.NoSuchElementException;
public class LinkedList<T> implements Iterable<T> {
private Node first;
private Node last;
private int N;
public LinkedList() {
first = null;
last = null;
N = 0;
}
public void add(T item) {
if (item == null) { throw new NullPointerException("The first argument for addLast() is null."); }
if (!isEmpty()) {
Node prev = last;
last = new Node(item, null);
prev.next = last;
}
else {
last = new Node(item, null);
first = last;
}
N++;
}
public boolean remove(T item) {
if (isEmpty()) { throw new IllegalStateException("Cannot remove() from and empty list."); }
boolean result = false;
Node prev = first;
Node curr = first;
while (curr.next != null || curr == last) {
if (curr.data.equals(item)) {
// remove the last remaining element
if (N == 1) { first = null; last = null; }
// remove first element
else if (curr.equals(first)) { first = first.next; }
// remove last element
else if (curr.equals(last)) { last = prev; last.next = null; }
// remove element
else { prev.next = curr.next; }
N--;
result = true;
break;
}
prev = curr;
curr = prev.next;
}
return result;
}
public int size() {
return N;
}
public boolean isEmpty() {
return N == 0;
}
private class Node {
private T data;
private Node next;
public Node(T data, Node next) {
this.data = data;
this.next = next;
}
}
public Iterator<T> iterator() { return new LinkedListIterator(); }
private class LinkedListIterator implements Iterator<T> {
private Node current = first;
public T next() {
if (!hasNext()) { throw new NoSuchElementException(); }
T item = current.data;
current = current.next;
return item;
}
public boolean hasNext() { return current != null; }
public void remove() { throw new UnsupportedOperationException(); }
}
@Override public String toString() {
StringBuilder s = new StringBuilder();
for (T item : this)
s.append(item + " ");
return s.toString();
}
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
while(!StdIn.isEmpty()) {
String input = StdIn.readString();
if (input.equals("print")) { StdOut.println(list.toString()); continue; }
if (input.charAt(0) == ('+')) { list.add(input.substring(1)); continue; }
if (input.charAt(0) == ('-')) { list.remove(input.substring(1)); continue; }
break;
}
}
}
class Node
{
int data;
Node link;
public Node()
{
data=0;
link=null;
}
Node ptr,start,temp;
void create()throws IOException
{
int n;
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter first data");
this.data=Integer.parseInt(br.readLine());
ptr=this;
start=ptr;
char ins ='y';
do
{
System.out.println("Wanna Insert another node???");
ins=(char)br.read();
br.read();
if(ins=='y')
{
temp=new Node();
System.out.println("Enter next data");
temp.data=Integer.parseInt(br.readLine());
temp.link=null;
ptr.link=temp;
temp=null;
ptr=ptr.link;
}
}while(ins=='y');
}
public static void main(String args[])throws IOException
{
Node first= new Node();
first.create();
}
}
package com.crunchify.tutorials;
/**
* @author Crunchify.com
*/
public class CrunchifyLinkedListTest {
public static void main(String[] args) {
CrunchifyLinkedList lList = new CrunchifyLinkedList();
// add elements to LinkedList
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
/*
* Please note that primitive values can not be added into LinkedList
* directly. They must be converted to their corresponding wrapper
* class.
*/
System.out.println("lList - print linkedlist: " + lList);
System.out.println("lList.size() - print linkedlist size: " + lList.size());
System.out.println("lList.get(3) - get 3rd element: " + lList.get(3));
System.out.println("lList.remove(2) - remove 2nd element: " + lList.remove(2));
System.out.println("lList.get(3) - get 3rd element: " + lList.get(3));
System.out.println("lList.size() - print linkedlist size: " + lList.size());
System.out.println("lList - print linkedlist: " + lList);
}
}
class CrunchifyLinkedList {
// reference to the head node.
private Node head;
private int listCount;
// LinkedList constructor
public CrunchifyLinkedList() {
// this is an empty list, so the reference to the head node
// is set to a new node with no data
head = new Node(null);
listCount = 0;
}
public void add(Object data)
// appends the specified element to the end of this list.
{
Node crunchifyTemp = new Node(data);
Node crunchifyCurrent = head;
// starting at the head node, crawl to the end of the list
while (crunchifyCurrent.getNext() != null) {
crunchifyCurrent = crunchifyCurrent.getNext();
}
// the last node's "next" reference set to our new node
crunchifyCurrent.setNext(crunchifyTemp);
listCount++;// increment the number of elements variable
}
public void add(Object data, int index)
// inserts the specified element at the specified position in this list
{
Node crunchifyTemp = new Node(data);
Node crunchifyCurrent = head;
// crawl to the requested index or the last element in the list,
// whichever comes first
for (int i = 1; i < index && crunchifyCurrent.getNext() != null; i++) {
crunchifyCurrent = crunchifyCurrent.getNext();
}
// set the new node's next-node reference to this node's next-node
// reference
crunchifyTemp.setNext(crunchifyCurrent.getNext());
// now set this node's next-node reference to the new node
crunchifyCurrent.setNext(crunchifyTemp);
listCount++;// increment the number of elements variable
}
public Object get(int index)
// returns the element at the specified position in this list.
{
// index must be 1 or higher
if (index <= 0)
return null;
Node crunchifyCurrent = head.getNext();
for (int i = 1; i < index; i++) {
if (crunchifyCurrent.getNext() == null)
return null;
crunchifyCurrent = crunchifyCurrent.getNext();
}
return crunchifyCurrent.getData();
}
public boolean remove(int index)
// removes the element at the specified position in this list.
{
// if the index is out of range, exit
if (index < 1 || index > size())
return false;
Node crunchifyCurrent = head;
for (int i = 1; i < index; i++) {
if (crunchifyCurrent.getNext() == null)
return false;
crunchifyCurrent = crunchifyCurrent.getNext();
}
crunchifyCurrent.setNext(crunchifyCurrent.getNext().getNext());
listCount--; // decrement the number of elements variable
return true;
}
public int size()
// returns the number of elements in this list.
{
return listCount;
}
public String toString() {
Node crunchifyCurrent = head.getNext();
String output = "";
while (crunchifyCurrent != null) {
output += "[" + crunchifyCurrent.getData().toString() + "]";
crunchifyCurrent = crunchifyCurrent.getNext();
}
return output;
}
private class Node {
// reference to the next node in the chain,
// or null if there isn't one.
Node next;
// data carried by this node.
// could be of any type you need.
Object data;
// Node constructor
public Node(Object dataValue) {
next = null;
data = dataValue;
}
// another Node constructor if we want to
// specify the node to point to.
public Node(Object dataValue, Node nextValue) {
next = nextValue;
data = dataValue;
}
// these methods should be self-explanatory
public Object getData() {
return data;
}
public void setData(Object dataValue) {
data = dataValue;
}
public Node getNext() {
return next;
}
public void setNext(Node nextValue) {
next = nextValue;
}
}
}
lList - print linkedlist: [1][2][3][4][5]
lList.size() - print linkedlist size: 5
lList.get(3) - get 3rd element: 3
lList.remove(2) - remove 2nd element: true
lList.get(3) - get 3rd element: 4
lList.size() - print linkedlist size: 4
lList - print linkedlist: [1][3][4][5]
import java.io.DataInputStream;
import java.io.IOException;
public class LinkedListTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Node root = null;
DataInputStream reader = new DataInputStream(System.in);
int op = 0;
while(op != 6){
try {
System.out.println("Enter Option:\n1:Insert Front 2:Delete Front 3:Insert Rear 4:Delete Rear 5:Display List 6:Exit");
//op = reader.nextInt();
op = Integer.parseInt(reader.readLine());
switch (op) {
case 1:
System.out.println("Enter Value: ");
int val = Integer.parseInt(reader.readLine());
root = insertNodeFront(val,root);
display(root);
break;
case 2:
root=removeNodeFront(root);
display(root);
break;
case 3:
System.out.println("Enter Value: ");
val = Integer.parseInt(reader.readLine());
root = insertNodeRear(val,root);
display(root);
break;
case 4:
root=removeNodeRear(root);
display(root);
break;
case 5:
display(root);
break;
default:
System.out.println("Invalid Option");
break;
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("Exited!!!");
try {
reader.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
static Node insertNodeFront(int value, Node root){
Node temp = new Node(value);
if(root==null){
return temp; // as root or first
}
else
{
temp.next = root;
return temp;
}
}
static Node removeNodeFront(Node root){
if(root==null){
System.out.println("List is Empty");
return null;
}
if(root.next==null){
return null; // remove root itself
}
else
{
root=root.next;// make next node as root
return root;
}
}
static Node insertNodeRear(int value, Node root){
Node temp = new Node(value);
Node cur = root;
if(root==null){
return temp; // as root or first
}
else
{
while(cur.next!=null)
{
cur = cur.next;
}
cur.next = temp;
return root;
}
}
static Node removeNodeRear(Node root){
if(root==null){
System.out.println("List is Empty");
return null;
}
Node cur = root;
Node prev = null;
if(root.next==null){
return null; // remove root itself
}
else
{
while(cur.next!=null)
{
prev = cur;
cur = cur.next;
}
prev.next=null;// remove last node
return root;
}
}
static void display(Node root){
System.out.println("Current List:");
if(root==null){
System.out.println("List is Empty");
return;
}
while (root!=null){
System.out.print(root.val+"->");
root=root.next;
}
System.out.println();
}
static class Node{
int val;
Node next;
public Node(int value) {
// TODO Auto-generated constructor stub
val = value;
next = null;
}
}
}
1 Insert At Start
2 Insert At End
3 Insert At any Position
4 Delete At any Position
5 Display
6 Get Size
7 Empty Status
8 Replace data at given postion
9 Search Element by position
10 Delete a Node by Given Data
11 Search Element Iteratively
12 Search Element Recursively
package com.elegant.ds.linkedlist.practice;
import java.util.Scanner;
class Node {
Node link = null;
int data = 0;
public Node() {
link = null;
data = 0;
}
public Node(int data, Node link) {
this.data = data;
this.link = null;
}
public Node getLink() {
return link;
}
public void setLink(Node link) {
this.link = link;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
}
class SinglyLinkedListImpl {
Node start = null;
Node end = null;
int size = 0;
public SinglyLinkedListImpl() {
start = null;
end = null;
size = 0;
}
public void insertAtStart(int data) {
Node nptr = new Node(data, null);
if (start == null) {
start = nptr;
end = start;
} else {
nptr.setLink(start);
start = nptr;
}
size++;
}
public void insertAtEnd(int data) {
Node nptr = new Node(data, null);
if (start == null) {
start = nptr;
end = nptr;
} else {
end.setLink(nptr);
end = nptr;
}
size++;
}
public void insertAtPosition(int position, int data) {
Node nptr = new Node(data, null);
Node ptr = start;
position = position - 1;
for (int i = 1; i < size; i++) {
if (i == position) {
Node temp = ptr.getLink();
ptr.setLink(nptr);
nptr.setLink(temp);
break;
}
ptr = ptr.getLink();
}
size++;
}
public void repleaceDataAtPosition(int position, int data) {
if (start == null) {
System.out.println("Empty!");
return;
}
Node ptr = start;
for (int i = 1; i < size; i++) {
if (i == position) {
ptr.setData(data);
}
ptr = ptr.getLink();
}
}
public void deleteAtPosition(int position) {
if (start == null) {
System.out.println("Empty!");
return;
}
if (position == size) {
Node startPtr = start;
Node endPtr = start;
while (startPtr != null) {
endPtr = startPtr;
startPtr = startPtr.getLink();
}
end = endPtr;
end.setLink(null);
size--;
return;
}
Node ptr = start;
position = position - 1;
for (int i = 1; i < size; i++) {
if (i == position) {
Node temp = ptr.getLink();
temp = temp.getLink();
ptr.setLink(temp);
break;
}
ptr = ptr.getLink();
}
size--;
}
public void deleteNodeByGivenData(int data) {
if (start == null) {
System.out.println("Empty!");
return;
}
if (start.getData() == data && start.getLink() == null) {
start = null;
end = null;
size--;
return;
}
if (start.getData() == data && start.getLink() != null) {
start = start.getLink();
size--;
return;
}
if (end.getData() == data) {
Node startPtr = start;
Node endPtr = start;
startPtr = startPtr.getLink();
while (startPtr.getLink() != null) {
endPtr = startPtr;
startPtr = startPtr.getLink();
}
end = endPtr;
end.setLink(null);
size--;
return;
}
Node startPtr = start;
Node prevLink = startPtr;
startPtr = startPtr.getLink();
while (startPtr.getData() != data && startPtr.getLink() != null) {
prevLink = startPtr;
startPtr = startPtr.getLink();
}
if (startPtr.getData() == data) {
Node temp = prevLink.getLink();
temp = temp.getLink();
prevLink.setLink(temp);
size--;
return;
}
System.out.println(data + " not found!");
}
public void disply() {
if (start == null) {
System.out.println("Empty!");
return;
}
if (start.getLink() == null) {
System.out.println(start.getData());
return;
}
Node ptr = start;
System.out.print(ptr.getData() + "->");
ptr = start.getLink();
while (ptr.getLink() != null) {
System.out.print(ptr.getData() + "->");
ptr = ptr.getLink();
}
System.out.println(ptr.getData() + "\n");
}
public void searchElementByPosition(int position) {
if (position == 1) {
System.out.println("Element at " + position + " is : " + start.getData());
return;
}
if (position == size) {
System.out.println("Element at " + position + " is : " + end.getData());
return;
}
Node ptr = start;
for (int i = 1; i < size; i++) {
if (i == position) {
System.out.println("Element at " + position + " is : " + ptr.getData());
break;
}
ptr = ptr.getLink();
}
}
public void searchElementIteratively(int data) {
if (isEmpty()) {
System.out.println("Empty!");
return;
}
if (start.getData() == data) {
System.out.println(data + " found at " + 1 + " position");
return;
}
if (start.getLink() != null && end.getData() == data) {
System.out.println(data + " found at " + size + " position");
return;
}
Node startPtr = start;
int position = 0;
while (startPtr.getLink() != null) {
++position;
if (startPtr.getData() == data) {
break;
}
startPtr = startPtr.getLink();
}
if (startPtr.getData() == data) {
System.out.println(data + " found at " + position);
return;
}
System.out.println(data + " No found!");
}
public void searchElementRecursively(Node start, int data, int count) {
if (isEmpty()) {
System.out.println("Empty!");
return;
}
if (start.getData() == data) {
System.out.println(data + " found at " + (++count));
return;
}
if (start.getLink() == null) {
System.out.println(data + " not found!");
return;
}
searchElementRecursively(start.getLink(), data, ++count);
}
public int getSize() {
return size;
}
public boolean isEmpty() {
return start == null;
}
}
public class SinglyLinkedList {
@SuppressWarnings("resource")
public static void main(String[] args) {
SinglyLinkedListImpl listImpl = new SinglyLinkedListImpl();
System.out.println("Singly Linked list : ");
boolean yes = true;
do {
System.out.println("1 Insert At Start :");
System.out.println("2 Insert At End :");
System.out.println("3 Insert At any Position :");
System.out.println("4 Delete At any Position :");
System.out.println("5 Display :");
System.out.println("6 Get Size");
System.out.println("7 Empty Status");
System.out.println("8 Replace data at given postion");
System.out.println("9 Search Element by position ");
System.out.println("10 Delete a Node by Given Data");
System.out.println("11 Search Element Iteratively");
System.out.println("12 Search Element Recursively");
System.out.println("13 Exit :");
Scanner scanner = new Scanner(System.in);
int choice = scanner.nextInt();
switch (choice) {
case 1:
listImpl.insertAtStart(scanner.nextInt());
break;
case 2:
listImpl.insertAtEnd(scanner.nextInt());
break;
case 3:
int position = scanner.nextInt();
if (position <= 1 || position > listImpl.getSize()) {
System.out.println("invalid position!");
} else {
listImpl.insertAtPosition(position, scanner.nextInt());
}
break;
case 4:
int deletePosition = scanner.nextInt();
if (deletePosition <= 1 || deletePosition > listImpl.getSize()) {
System.out.println("invalid position!");
} else {
listImpl.deleteAtPosition(deletePosition);
}
break;
case 5:
listImpl.disply();
break;
case 6:
System.out.println(listImpl.getSize());
break;
case 7:
System.out.println(listImpl.isEmpty());
break;
case 8:
int replacePosition = scanner.nextInt();
if (replacePosition < 1 || replacePosition > listImpl.getSize()) {
System.out.println("Invalid position!");
} else {
listImpl.repleaceDataAtPosition(replacePosition, scanner.nextInt());
}
break;
case 9:
int searchPosition = scanner.nextInt();
if (searchPosition < 1 || searchPosition > listImpl.getSize()) {
System.out.println("Invalid position!");
} else {
listImpl.searchElementByPosition(searchPosition);
}
break;
case 10:
listImpl.deleteNodeByGivenData(scanner.nextInt());
break;
case 11:
listImpl.searchElementIteratively(scanner.nextInt());
break;
case 12:
listImpl.searchElementRecursively(listImpl.start, scanner.nextInt(), 0);
break;
default:
System.out.println("invalid choice");
break;
}
} while (yes);
}
}
class Node {
int data;
Node next;
public Node(int data) {
this.data = data;
this.next = null;
}
}
public class LinkedListManual {
Node node;
public void pushElement(int next_node) {
Node nd = new Node(next_node);
nd.next = node;
node = nd;
}
public int getSize() {
Node temp = node;
int count = 0;
while (temp != null) {
count++;
temp = temp.next;
}
return count;
}
public void getElement() {
Node temp = node;
while (temp != null) {
System.out.println(temp.data);
temp = temp.next;
}
}
public static void main(String[] args) {
LinkedListManual obj = new LinkedListManual();
obj.pushElement(1);
obj.pushElement(2);
obj.pushElement(3);
obj.getElement(); //get element
System.out.println(obj.getSize()); //get size of link list
}
}