JAVAはシングルチェーンの添削を実現します.
26999 ワード
前言
実現参考:
http://blog.csdn.net/hitwhylz/article/details/12305021
http://www.cnblogs.com/smyhvae/p/4761593.html
上記のブログを読むことをお勧めします.私のブログは上のブログが読めます.
実現する機能
増加位置指定ノード は、末尾にノード を追加する.
削除は、指定されたノードを削除し、ノードデータ(重複していないと仮定する)によって を削除する.指定位置ノード を削除する.
変更指定位置ノードデータを修正する クエリーは、あるノードの位置を問い合わせる .は、ある位置のノードデータ を照会する.は、あるデータがチェーンテーブルに存在するかどうかを調べる(データが重複していないと仮定する) .
行列を回転チェーンを行列 に変換します.
中国語版ダミーコード
初めて汎型を使います.
静的な内部クラスと非静的な内部クラスの区別静的な内部クラスは外部クラスにアクセスできない非静的なメンバーは、静的な内部クラスを独立させたようなものです.
チェーンの各種操作に時間がかかります!一つを調べて、一つを調べたら巡回します.誰もいません.
頭の中には多くの概念があります.目的の指針のような概念があります.どの位置に行けばいいのかを指定して要素を得ることができます.泳げというのが適当かどうかは分かりませんが、とにかく泳いでいて忙しいです.私の実現の中のcurrNodeはいつも頭を走って最後に走ります.
チェーンを操作して配列にすると効率が上がるかもしれません.
自分が異常に対して脳の空白に慣れていないことを発見しました.
END
実現参考:
http://blog.csdn.net/hitwhylz/article/details/12305021
http://www.cnblogs.com/smyhvae/p/4761593.html
上記のブログを読むことをお勧めします.私のブログは上のブログが読めます.
実現する機能
増加
削除
変更
行列を回転
中国語版ダミーコード
/**
*
*
* ：
*
*
* ：
* ， ，
* ：
* ， ， 。
*
*
* ： next
* ： ，
* n
* ：
* n-1
* n-1 next
* n-1 next
* （ ）：
* next
* next
*
*
*
* ， n
* n-1
* n-1 next n+1
*
*
* n
* n (n >= 0 && n < size)
*
* n-1
* n-1 next n+1
*
*
*
*
*
*
*
*
* ，
* ， -1
* ， n
*
* n，
* ，
*
*
* ，
* ，
*
*
*
*
*
*
*
*
*/public class SingleLinkedList {
private Node headNode;
private Node currNode;
private int size;
SingleLinkedList() {
headNode = new Node();
currNode = null;
size = 0;
}
public int Size() {
return size;
}
//
public void insert(T data) {
Node tNode = new Node(data);
if (isEmpty()) {
headNode.setNext(tNode);
} else {
toIndexOf(size - 1);
currNode.setNext(tNode);
}
size++;
}
// n
public void insert(T data, int n) {
// n-1
toIndexOf(n - 1);
// ，
if (isEmpty()) {
insert(data);
return;
}
// next n , n-1 next
// n ， n n+1
currNode.setNext(new Node(data, currNode.getNext()));
size++;
}
// n
public T get(int n) {
// n
toIndexOf(n);
return (T) currNode.getData();
}
//
public int getElemAt(T data) {
if (data == null) {
throw new NullPointerException(" null， 。");
}
currNode = headNode.getNext();
int i = 0;
while (currNode != null) {
if (currNode.getData().equals(data)) {
return i;
}
i++;
currNode = currNode.getNext();
}
return -1;
}
//
public boolean setElemAt(T data, int n) {
toIndexOf(n);
currNode.setData(data);
return true;
}
//
public boolean contains(T data) {
return getElemAt(data) == -1 ? false : true;
}
// n
public T delete(int n) {
toIndexOf(n - 1);
T data = currNode.getNext().getData();
currNode.setNext(currNode.getNext().getNext());
size--;
return data;
}
//
public T deleteElemBy(T data) {
int n = getElemAt(data);
return delete(n);
}
public boolean isEmpty() {
return size == 0 ? true : false;
}
//
public Object[] toArray() {
if (isEmpty()) {
throw new IndexOutOfBoundsException("Size: " + size);
}
Object[] arr = new Object[size];
toIndexOf(0);
int i = 0;
while (currNode != null) {
arr[i++] = currNode.getData();
currNode = currNode.getNext();
}
return arr;
}
//
private void toIndexOf(int n) {
if (isEmpty() || !isIndexOk(n)) {
throw new IndexOutOfBoundsException("Index: " + n + ", Size: " + size);
}
currNode = headNode;
if (n == -1) return;
while (n != -1) {
currNode = currNode.getNext();
n--;
}
}
private boolean isIndexOk(int n) {
if (n < -1 || n >= size) return false;
return true;
}
private class Node {
private T data;
private Node next;
Node() {
}
Node(T data) {
this.data = data;
}
Node(T data, Node nextNode) {
this.data = data;
this.next = nextNode;
}
public T getData() {
return data;
}
public Node getNext() {
return next;
}
public void setData(T data) {
this.data = data;
}
public void setNext(Node next) {
this.next = next;
}
}
} public class LinkedListTest {
public static void main(String[] args) {
SingleLinkedList test = new SingleLinkedList();
for (int i = 0; i < 10; i++) {
test.insert(i);
}
//System.out.println("------------ --------------");
//System.out.println(test.get(-1));
//System.out.println(test.get(test.Size()));
System.out.println(" ：");
System.out.print(test.get(0) + ",");
System.out.print(test.get(4) + ",");
System.out.println(test.get(test.Size() - 1));
System.out.println("------------ --------------");
Object[] data = test.toArray();
showArray(data);
System.out.println("------------ --------------");
int el1 = 2, el2 = 22;
System.out.println(el1 + " at " + test.getElemAt(2));
System.out.println(el2 + " at " + test.getElemAt(22));
System.out.println("------------ --------------");
data = test.toArray();
showArray(data);
System.out.println(" ， ");
System.out.print(test.delete(9) + ",");
System.out.print(test.delete(0) + ",");
System.out.println(test.delete(3));
System.out.println(" ");
data = test.toArray();
showArray(data);
System.out.println(" ， ：");
System.out.print(test.deleteElemBy(1) + ",");
System.out.print(test.deleteElemBy(8) + ",");
System.out.println(test.deleteElemBy(5));
System.out.println(" ：");
data = test.toArray();
showArray(data);
System.out.println("------------ --------------");
data = test.toArray();
showArray(data);
int n1 = 6, n2 = 10;
System.out.println(n1 + "， ？" + test.contains(n1));
System.out.println(n2 + "， ？" + test.contains(n2));
System.out.println("------------ --------------");
data = test.toArray();
showArray(data);
test.insert(4, 2);
test.insert(5, 3);
System.out.println(" 4、5 2、3 ， ：");
data = test.toArray();
showArray(data);
System.out.println("------------ --------------");
data = test.toArray();
showArray(data);
test.setElemAt(1024, 2);
test.insert(2048, 3);
System.out.println(" 2、3 1024、2048， ：");
data = test.toArray();
showArray(data);
test.setElemAt(6, 10);
}
public static void showArray(Object[] data) {
int len = data.length - 1;
for (int i = 0; i <= len; i++) {
System.out.print(data[i]);
System.out.print(i < len ? " " : "");
}
System.out.println();
}
} ：
0,4,9
------------ --------------
0 1 2 3 4 5 6 7 8 9
------------ --------------
2 at 2
22 at -1
------------ --------------
0 1 2 3 4 5 6 7 8 9
，
9,0,4
1 2 3 5 6 7 8
， ：
1,8,5
：
2 3 6 7
------------ --------------
2 3 6 7
6， ？true
10， ？false
------------ --------------
2 3 6 7
4、5 2、3 ， ：
2 3 4 5 6 7
------------ --------------
2 3 4 5 6 7
2、3 1024、2048， ：
2 3 1024 2048 5 6 7
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 10, Size: 7
at SingleLinkedList.toIndexOf(SingleLinkedList.java:183)
at SingleLinkedList.setElemAt(SingleLinkedList.java:135)
at LinkedListTest.main(LinkedListTest.java:68)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:497)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)初めて汎型を使います.
静的な内部クラスと非静的な内部クラスの区別静的な内部クラスは外部クラスにアクセスできない非静的なメンバーは、静的な内部クラスを独立させたようなものです.
チェーンの各種操作に時間がかかります!一つを調べて、一つを調べたら巡回します.誰もいません.
頭の中には多くの概念があります.目的の指針のような概念があります.どの位置に行けばいいのかを指定して要素を得ることができます.泳げというのが適当かどうかは分かりませんが、とにかく泳いでいて忙しいです.私の実現の中のcurrNodeはいつも頭を走って最後に走ります.
チェーンを操作して配列にすると効率が上がるかもしれません.
自分が異常に対して脳の空白に慣れていないことを発見しました.
END