LinkedListクラスをゼロから作成する
LinkedListをゼロから作成する割り当てが与えられましたが、この移行の原因となるタスクをガイドする読み取り値はまったくありません。また、オンラインではすべて、Javaに組み込まれたLinkedListメソッドなどを使用しているようです。とにかく、Javaのデフォルトのものを使用する場合、リンクリストは完全に意味がありますが、ゼロから作成することはまったく意味がありません。私が持っているとしましょう
public class LinkedList {
private LinkedList next;
private final String Word;
// constructor
public LinkedList(String Word, LinkedList next) {
this.Word = Word;
this.next = next;
}
したがって、魔法のようにリンクリストがあります。何が起こっている？このようなリンクリストを作成するにはどうすればよいですか？これはどのように作動しますか？特定のString Wordパラメーターをthis linkedlistの最後に追加するappendメソッドを記述することになっています。ビルトインJava linkedlistクラスのaddLastビルトインメソッドを見てみましたが、何が起こっているのか本当に理解していないので、私には何の助けにもなりません。
実際に実際のシステムを構築している場合、はい、必要なものがそこにある場合は、通常は標準ライブラリにあるものだけを使用します。とはいえ、これを無意味な運動と考えないでください。物事の仕組みを理解するのは良いことです。リンクリストを理解することは、より複雑なデータ構造を理解するための重要なステップです。データ構造の多くは標準ライブラリには存在しません。
リンクリストを作成する方法とJavaコレクションAPIが行う方法には、いくつかの違いがあります。コレクションAPIは、より複雑なインターフェースに準拠しようとしています。 listは二重リンクリストでもありますが、単リンクリストを作成している場合は、クラスの割り当てにより適しています。
LinkedListクラスを使用すると、インスタンスは常に少なくとも1つの要素のリストになります。この種のセットアップでは、空のリストが必要な場合にnullを使用します。
nextを「リストの残り」と考えてください。実際、多くの同様の実装では、「next」ではなく「tail」という名前を使用しています。
3つの要素を含むLinkedListの図を次に示します。
これは、Word（ "Hello"）と2つの要素のリストを指すLinkedListオブジェクトであることに注意してください。 2つの要素のリストには、Word（「スタック」）と1つの要素のリストがあります。 1要素のリストには、Word（「オーバーフロー」）と空のリスト（null）があります。したがって、nextは、たまたま1つの要素より短い別のリストとして扱うことができます。
Stringを取り、nullの隣に設定する別のコンストラクターを追加することもできます。これは、1要素のリストを作成するためのものです。
追加するには、nextがnullであるかどうかを確認します。ある場合は、新しい1つの要素リストを作成し、nextをそれに設定します。
next = new LinkedList(Word);
Nextがnullでない場合、代わりにnextに追加します。
next.append(Word);
これは再帰的アプローチであり、コードの量は最小です。これをJavaでより効率的な反復ソリューションに変えることができます*、非常に長いリストでスタックオーバーフローのリスクはありませんが、割り当てには複雑さのレベルは必要ないと推測しています。
*一部の言語にはテールコールの除去があります。これは、言語実装が「テールコール」（戻る前の最後のステップとして別の関数を呼び出す）を（効果的に）「goto」に変換する最適化です。これにより、このようなコードはスタックの使用を完全に回避するため、より安全になり（スタックを使用しない場合はスタックをオーバーフローさせることはできません）、通常はより効率的になります。 Schemeは、おそらくこの機能を備えた言語の最もよく知られた例です。
あなたがコーディングしたものは LinkedList ではなく、少なくとも私が認識するものではありません。この割り当てでは、2つのクラスを作成します。
LinkNode
LinkedList
LinkNodeには、含まれるデータ用の1つのメンバーフィールドと、LinkNode内の次のLinkNodeへのLinkedList参照があります。はい、それは自己参照データ構造です。 LinkedListには、リストの最初の項目を参照する特別なLinkNode参照があります。
LinkedListにアイテムを追加すると、すべてのLinkNode's最後に到達するまで。この LinkNode's nextはnullでなければなりません。次に、ここで新しい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
}
}
非再帰リンクリストの完全に機能的な実装はどうですか？
これは、割り当ての二重リンクキュークラスの記述に移る前に、より良い理解を得るための足がかりとして、クラスのアルゴリズム用に作成しました。
コードは次のとおりです
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;
}
}
}
注：これは、単一リンクリストの非常に基本的な実装です。 「T」タイプは汎用タイプのプレースホルダーです。基本的に、このリンクリストは、Objectを継承するすべてのタイプで機能するはずです。プリミティブ型に使用する場合は、同等のヌル可能クラスを使用してください（「int」型の場合は「Integer」など）。 'last'変数は、挿入をO(1)時間に短縮することを除いて、実際には必要ありません。削除は、O(N) =時間ですが、リスト内の値の最初の出現を削除できます。
必要に応じて、実装も検討できます。
- addFirst（）-LinkedListの先頭に新しいアイテムを追加します
- removeFirst（）-LinkedListから最初のアイテムを削除します
- removeLast（）-LinkedListから最後のアイテムを削除します
- addAll（）-アイテムのリスト/配列をLinkedListに追加します
- removeAll（）-LinkedListからアイテムのリスト/配列を削除します
- contains（）-LinkedListにアイテムが含まれているかどうかを確認します
- contains（）-LinkedList内のすべてのアイテムをクリアします
正直なところ、これを二重リンクリストにするのに数行のコードしか必要ありません。これと二重リンクリストの主な違いは、Node二重リンクリストのインスタンスには、リスト内の前の要素を指す追加の参照が必要です。
再帰的な実装に対するこの利点は、高速であり、大きなリストをトラバースするときにスタックがあふれることを心配する必要がないことです。
デバッガー/コンソールでこれをテストするための3つのコマンドがあります。
- 値の先頭に「+」を付けると、リストに追加されます。
- 「-」を前に付けると、リストから最初に出現したものが削除されます。
- 「print」と入力すると、値がスペースで区切られたリストが出力されます。
これらの1つがどのように機能するかの内部を見たことがない場合は、デバッガーで次の手順を実行することをお勧めします。
- add（）-新しいノードを最後に追加するか、リストが空の場合は最初/最後の値を初期化します
- remove（）-リストを最初から最後までウォークします。一致するものが見つかった場合、そのアイテムを削除し、チェーン内の前のリンクと次のリンクの間の壊れたリンクを接続します。前または次のリンクがない場合、特別な例外が追加されます。
- toString（）-foreachイテレータを使用して、リストチェーンを最初から最後まで単純にたどります。
配列リストなどのリストにはより優れた効率的なアプローチがありますが、参照/ポインターを介してアプリケーションが移動する方法を理解することは、より多くの高レベルのデータ構造が機能する数を理解するために不可欠です。
ヒント1：リンクリストの説明を http://en.wikipedia.org/wiki/Linked_list で読む
ヒント2：LinkedListのJava実装は二重リンクリストです。あなたのものは単一リンクリストです。アルゴリズムは直接適用されません。
また：
...しかし、[リンクリストクラス]をゼロから作成することはまったく意味がありません。
それは、作業の必要な結果によって異なります。特定の機能/非機能要件を満たすコードを生成することが目標である場合、あなたは正しいです。 real目標があなたのためである場合learnプログラミング/設計方法API /重要なデータ構造を実装する場合、最終製品の有用性はほとんど完全に無関係です。
したがって、魔法のようにリンクされたリストがあります
あなたが実際に持っているのは、（ある種の）リストを作成するために使用できるオープンなデータ型です。しかし、それは先生が望んでいることではありません。そして、それは確かに有用なリスト抽象化とは見なされないでしょう。便利な抽象化には次のものが含まれます。
プログラマーが何度も繰り返したくないようなことをする方法
プログラマーがリストを「壊す」のを防ぐ抽象化レイヤー。例えば誤ってサイクルを作成したり、サブリストを誤って2つのリストにつないで逆ツリーを作成したりすることによって。
確かに、Linked Listはn00bsのプログラミングに少し混乱を招きます。それをLinkedList ObjectのLinkedList Objectのように見えるので、ロシアの人形として見たくなる誘惑がほとんどあります。しかし、それは視覚化するのが難しいタッチです。代わりにコンピューターのように見てください。
LinkedList =データ+次のメンバー
NextがNULLの場合、リストの最後のメンバー
したがって、5メンバーLinkedListは次のようになります。
LinkedList（Data1、LinkedList（Data2、LinkedList（Data3、LinkedList（Data4、LinkedList（Data5、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!
}
これはもちろん非常に単純なコードであり、循環リンクリストをフィードするとwill無限ループになります！しかし、それが基本です。
次の機能を備えたリンクリストプログラム
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);
}
}
リンクされたリストで役立ちます。
Javaでの前面の挿入、前面の削除、背面の挿入、背面の削除の操作を示すリンクリスト：
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;
}
}
}
このようにリンクリストを作成した方法。これはどのように機能しますか？これがすべてリンクリストです。リスト内の次のアイテムへのリンクを持つアイテム。リストの先頭にあるアイテムへの参照を保持している限り、次の値への後続の各参照を使用して全体を走査できます。
追加するには、リストの最後を見つけて、次の項目を追加する値にするだけです。したがって、nullが次にない場合は、次の項目でappendを呼び出す必要があります。リストの最後。
this.next.Append(Word);
この記事をお読みください： JavaでゼロからLinkedListクラスを実装する方法
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]
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 } }