單向鏈表java
㈠ java中單向鏈表用的多嗎
java中單向鏈表用的多.
這是我寫的一個差不多，你看一下吧：
package com.test.list;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class LinkedList {
public static void main(String[] args) {
MyList l = new MyList();
MyListNode node = l.createList();
l.printNode(node);
//l.searchNode(node, 4);
//node = l.insertNode(node, 3, "g");
//l.printNode(node);
node = l.deleteNode(node, "d");
l.printNode(node);
}
}
class MyListNode {
public String data;
public MyListNode nextNode;
}
class MyList {
public MyListNode createList() {
MyListNode node = new MyListNode();
MyListNode q ,p;
q = new MyListNode();
q = node;
while (true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("請輸入節點數據：");
s = br.readLine();
if (s.equals("0")) {
break;
} else {
p = new MyListNode();
p.data = s;
p.nextNode = null;
q.nextNode = p;
q = p;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
public void printNode(MyListNode node) {
MyListNode p = node.nextNode;
while (p!= null) {
System.out.print(" "+p.data);
p = p.nextNode;
}
}
public void searchNode(MyListNode node, int i){
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i) {
p = p.nextNode;
j++;
}
if( p == null || j>i) {
System.out.println("error");
}
System.out.println(" --"+p.data+"--");
}
public MyListNode insertNode(MyListNode node, int i ,String s) {
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i-1) {
p = p.nextNode;
j++;
}
if( p == null || j>i-1) {
System.out.println("error");
}
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = p.nextNode;
p.nextNode = n;
return node;
}
public MyListNode deleteNode(MyListNode node ,String s) {
MyListNode p = node;
while(p.nextNode != null && !p.nextNode.data.equals(s)) {
p = p.nextNode;
}
p.nextNode = p.nextNode.nextNode;
return node;
}
}
/*逆位序創建
public MyListNode createList() {
MyListNode node = new MyListNode();
node.nextNode = null;
while(true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("請輸入節點數據：");
s = br.readLine();
if(s.equals("0")) {
break;
}else {
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = node.nextNode;
node.nextNode = n;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
*/
㈡ Java單向鏈表代碼。
這是我寫的一個差不多，你看一下吧：
package com.test.list;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class LinkedList {
public static void main(String[] args) {
MyList l = new MyList();
MyListNode node = l.createList();
l.printNode(node);
//l.searchNode(node, 4);
//node = l.insertNode(node, 3, "g");
//l.printNode(node);
node = l.deleteNode(node, "d");
l.printNode(node);
}
}
class MyListNode {
public String data;
public MyListNode nextNode;
}
class MyList {
public MyListNode createList() {
MyListNode node = new MyListNode();
MyListNode q ,p;
q = new MyListNode();
q = node;
while (true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("請輸入節點數據：");
s = br.readLine();
if (s.equals("0")) {
break;
} else {
p = new MyListNode();
p.data = s;
p.nextNode = null;
q.nextNode = p;
q = p;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
public void printNode(MyListNode node) {
MyListNode p = node.nextNode;
while (p!= null) {
System.out.print(" "+p.data);
p = p.nextNode;
}
}
public void searchNode(MyListNode node, int i){
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i) {
p = p.nextNode;
j++;
}
if( p == null || j>i) {
System.out.println("error");
}
System.out.println(" --"+p.data+"--");
}
public MyListNode insertNode(MyListNode node, int i ,String s) {
MyListNode p = node.nextNode;
int j = 1;
while (p != null && j<i-1) {
p = p.nextNode;
j++;
}
if( p == null || j>i-1) {
System.out.println("error");
}
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = p.nextNode;
p.nextNode = n;
return node;
}
public MyListNode deleteNode(MyListNode node ,String s) {
MyListNode p = node;
while(p.nextNode != null && !p.nextNode.data.equals(s)) {
p = p.nextNode;
}
p.nextNode = p.nextNode.nextNode;
return node;
}
}
/*逆位序創建
public MyListNode createList() {
MyListNode node = new MyListNode();
node.nextNode = null;
while(true) {
String s = null;
try {
BufferedReader br = new BufferedReader(new InputStreamReader(
System.in));
System.out.println("請輸入節點數據：");
s = br.readLine();
if(s.equals("0")) {
break;
}else {
MyListNode n = new MyListNode();
n.data = s;
n.nextNode = node.nextNode;
node.nextNode = n;
}
} catch (Exception e) {
e.printStackTrace();
}
}
return node;
}
*/
㈢ java 什麼是單向鏈表 和 雙向鏈表
鏈表是類似一種數據結構的東西，就是分別存放有地址以及數據單項鏈表一般是上一個存放地址的地方存放下一個節點的地址，而雙向的就是有兩個存放地址的地方，分別存上一個以及下一個的地址。大概是這樣子
㈣ java數據結構單鏈表
你的問題很好理解。但是你的代碼問題嚴重。
1、你想用java代碼實現還是c代碼實現？從你的代碼看是c語言
2、第一段代碼中的結構體nod是不是應該寫成Node？
3、inset函數中，鏈表L是有變化的，所以要用指針。結點s是不改變的，所以不應該用指針
4、既然s不是用指針，後面的s->next自然也不能這么寫了。
㈤ Java單鏈表的問題
class Node{ private Object data; private Node next; Node (){} Node (Object data) { this.setData(data); this.setNext(null); } public void setData(Object data){ this.data = data; } public void setNext(Node next){ this.next = next; } public Object getData(){ return this.data; } public Node getNext(){ return this.next; } public String printNode(){ return "節點內的內容為："+this.getData(); } public boolean equals(Node node){ if(this.getData().equals(node.getData())) return true; else return false; } } class SingleLink{ private Node root; private int size; SingleLink() { this.setSize(); } public void setSize(){ if(this.root==null) { size = 0; } Node temp; temp = this.root; while(temp!=null){ size++; temp = temp.getNext(); } } public int getSize(){ return this.size; } public Node addNode(Node newNode){ if(this.root == null){ this.root = newNode; size++; return this.root; } Node temp = this.root; while(temp.getNext()!=null){ temp = temp.getNext(); } temp.setNext(newNode); size++; return this.root; } public void print(){ if(this.root == null ){ System.out.println("鏈表不存在！"); } int count=0; Node temp; temp = this.root; while(temp!=null) { System.out.print("第"+(++count)+"個"+temp.printNode()+"->"); temp=temp.getNext(); } System.out.println(); } public boolean search(Object data){ if(this.root == null ){ System.out.println("鏈表不存在！"); return false; } boolean flag = false; Node temp; temp=this.root; while(temp!=null){ if(temp.getData().equals(data)){ flag = true; break; } temp = temp.getNext(); } return flag; } public void deleteNode(Object data){ if(this.root == null ){ System.out.println("鏈表不存在！"); } Node temp; temp=this.root; while(temp!=null){ if(temp.getNext().getData().equals(data)){ break; } temp = temp.getNext(); } if(temp==null){ System.out.println("未找到節點！"); } else { temp.setNext(temp.getNext().getNext()); } } } public class LinkDemo{ public static void main(String args[]){ Node node依 = new Node("第依個節點"); Node node貳 = new Node("第貳個節點"); Node node三 = new Node("第三個節點"); Node node四 = new Node("第四個節點"); Node node5 = new Node("第5個節點"); Node node陸 = new Node("第陸個節點"); SingleLink singleLink = new SingleLink(); //System.out.println(singleLink.getSize()); singleLink.addNode(node依); singleLink.addNode(node貳); singleLink.addNode(node三); singleLink.addNode(node四); singleLink.addNode(node5); singleLink.addNode(node陸); //System.out.println(singleLink.getSize()); //singleLink.print(); if(singleLink.search("第漆個節點")) { System.out.println("節點存在！"); } else{ System.out.println("節點不存在！"); } singleLink.deleteNode("第貳個節點"); singleLink.print();
㈥ java單向鏈表基礎知識~~求通俗解答
話說...通俗解答啊...給你個比喻吧...
自行車都騎過吧...自行車的齒輪用的鏈子看過吧...
如果你拆開過應該發現其實是一節一節組成的,也就是說這一節一節的單個的組成鏈子的東西是組成車鏈的基本元素
然後再對應回去...這個一個個一節的東西就是鏈表中的一個個節點,需要注意的是,鏈表中的一個個節點可以是一個個對象,而對象又可以是別的數組或者什麼東西.
至於單向鏈表就是你把那個車鏈子弄斷,然後如果你向著一個方向一直前進移動,總會有盡頭,這兩個指針就是頭指針和終結指針.
然後鏈表分三種,單向鏈表,雙向鏈表和循環鏈表
在單向鏈表中,你只能從一個節點到下一個節點,因為它只包含一個指向下個節點的指針和一個對象.你可以把節點理解為一個對象,它包含的信息有1個指針(指向下個節點的地址),一個指針的值,就是一個對象.
雙向鏈表是單向鏈表的加強版,它含有2個指針(比單向鏈表多一個),一個指向上一個節點的地址,另一個指向下一個節點的地址,所以它能夠雙向移動讀取.
循環鏈表是雙向鏈表的加強版,雙向鏈表的所有節點是一條線的線性排列,然後你將頭節點的上一個節點的指針指向終結節點,然後將終結節點的下一個節點的指針指向頭節點,就相當於你將一個斷開的車鏈重新修好了,不過這里的連接是靠指針的指向而已,然後它就成一條線變成了一個圓,然後這就是循環鏈表了...
還有什麼不懂的可以問我
㈦ 用Java語言實現單向鏈表
1.先定義一個節點類
package com.buren;
public class IntNode {
//定義一個節點類
int
info;
//定義屬性，節點中的值
IntNode next;
//定義指向下一個節點的屬性
public IntNode(int
i){ //構造一個next為空的節點
this(i,null);
}
public IntNode(int i,IntNode
n){ //構造值為i指向n的節點
info=i;
next=n;
}
}
2.再定義一個鏈表類，這是主要部分
package com.buren;
public class IntSLList {
private IntNode head,tail;
//定義指向頭結點和尾結點的指針，
//如果大家看著這個不像指針的話，那就需要對指針有更深刻的了解
public
IntSLList(){
//定義一個空節點
head=tail=null;
}
public boolean
isEmpty(){
//判斷節點是否為空
return
head==null;
//這行代碼看起來似乎很神奇，其實真的很神奇，偶是服了
}
public void addToHead(int el){
//將el插入到頭結點前
head=new
IntNode(el,head);
//將節點插入到頭結點前，作為新的投節點
if(head==tail){
//給空鏈表插入節點時
tail=head;
//頭結點和尾結點指向同一個節點
}
}
public void addToTail(int
el){
//向鏈表的尾部增加結點
if(!isEmpty()){
//判斷鏈表是否為空
tail.next=new
IntNode(el);
//新建立一個值為el的節點，將鏈表的尾結點指向新節點
tail=tail.next;
//更新尾指針的指向
}else{
head=tail=new
IntNode(el);
//如果鏈表為空，新建立一個節點，將頭尾指針同時指向這個節點
}
}
public int
deleteFromHead(){
//刪除頭結點，將節點信息返回
int
el=head.info;
//取出節點信息
if(head==tail){
//如果鏈表中只有一個節點
head=tail=null;
//刪除這一個節點
}else{
head=head.next;
//如果鏈表中不止一個節點，將頭結點的下一個節點作為頭結點
}
return
el;
//返回原頭結點的值
}
public int
deleteFromTail(){
//刪除尾結點，返回尾結點的信息
int
el=tail.info;
//取出尾結點的值
if(head==tail){
// 如果鏈表中只有一個節點
head=tail=null;
//刪除這個節點
}else{
IntNode
temp;
//定義中間變數
for(temp=head;temp.next!=tail;temp=temp.next);
//找出尾結點的前一個節點，注意最後的分號，
//這個for循環是沒有循環體的，目的在於找出尾結點的前一個節點
//在整個程序中用了很多次這樣的寫法，相當經典啊
tail=temp;
//將找出來的節點作為尾結點，刪除原來的尾結點
tail.next=null;
//將新尾結點的指向設為空
}
return
el;
//返回原尾結點的信息
}
public void
printAll(){
//列印鏈表中所有節點的信息
if(isEmpty()){
//如果鏈表為空
System.out.println("This
list is
empty!");
//輸出提示信息
return;
//返回到調用的地方
}
if(head==tail){
//當鏈表中只有一個節點時
System.out.println(head.info);
//輸出這個節點的信息，就是頭結點的信息
return;
}
IntNode
temp;
//定義一個中間變數
for(temp=head;temp!=null;temp=temp.next){
//遍歷整個鏈表
System.out.print(temp.info+"
");
//輸出每個節點的信息
}
System.out.println();
//輸出一個換行，可以沒有這一行
}
public boolean isInList(int
el){
//判斷el是否存在於鏈表中
IntNode
temp;
//定義一個中間變數
for(temp=head;temp!=null
&&
temp.info!=el;temp=temp.next);
//將el找出來，注意最後的分
return
temp!=null;
// 如果存在返回true，否則返回flase，這兩行代碼很有思想
}
public void delete(int
el){
//刪除鏈表中值為el的節點
if(head.info==el
&&
head==tail){
//如果只有一個節點，並且節點的值為el
head=tail=null;
//刪除這個節點
}else
if(head.info==el){
// 不止一個節點，而頭結點的值就是el
head=head.next;
//刪除頭結點
}else{
IntNode
pred,temp;
//定義兩個中間變數
for(pred=head,temp=head.next;temp.info!=el
&&
temp.next!=null;pred=pred.next,temp=temp.next);
//跟上面的類似，自己琢磨吧，也是要注意最後的分號
pred.next=temp.next;
//將temp指向的節點刪除，最好畫一個鏈表的圖，有助於理解
if(temp==tail){
//如果temp指向的節點是尾結點
tail=pred;
//將pred指向的節點設為尾結點，
}
}
}
//下面這個方法是在鏈表中值為el1的節點前面插入一個值為el2的節點，
//用類似的思想可以再寫一個在鏈表中值為el1的節點後面插入一個值為el2的節點
public boolean insertToList(int el1,int
el2){
//定義一個插入節點的方法，插入成功返回true，否則返回false
IntNode
pred,temp; //定義兩個中間變數
if(isEmpty()){
//判斷鏈表是否為空
return
false;
//如果鏈表為空就直接返回false
}
if(head.info==el1
&&
head==tail){
//如果鏈表中只有一個節點，並且這個節點的值是el1
head=new
IntNode(el2,head);
//新建立一個節點
return
true;
}else if(head.info==el1){
IntNode t=new
IntNode(el2);
t.next=head;
head=t;
return
true;
}else{
for(pred=head,temp=head.next;temp!=null
&&
temp.info!=el1;pred=pred.next,temp=temp.next);
if(temp!=null){
IntNode
a=new IntNode(el2);
pred.next=a;
a.next=temp;
return
true;
}else{
System.out.println(el1+"
NOT EXEISTS!");
return
false;
}
}
}
3.下面是測試代碼
public static void main(String[] args){
IntSLList test=new
IntSLList();
//test.addToHead(7);
test.addToTail(7);
System.out.println(test.insertToList(7,5));
test.printAll();
System.out.println(test.isInList(123));
}
}
㈧ java 單向鏈表為什麼是無序的
我剛看了IT黑馬的同一個教學視頻，我當時也沒看懂，不過我現在有了一點猜想。
我想你的疑惑是單鏈表理論上明明是可以做到有序的（比如用C++，程序員來安排每個節點的指針），但為什麼這里說單鏈是無序的呢？我覺得這有可能和這個類的底層實現機制有關系。
例如在插入的時候，JVM優先考慮的是存儲空間上的順序以提高執行效率，所以這條鏈的順序可能是節點在堆內存上的順序，所以對於它存儲的信息或是存入的先後而言就是無序的了。至於雙鏈表為什麼有序，則可能是因為設計者認為已經用一條鏈保證了鏈表結構和執行效率，那麼第二條鏈就沒有必要按部就班的成為第一條鏈的反向，而可以被用來記錄你要的順序，因此雙向鏈表是有序的。
其實我也不知道我的猜想是否正確，我沒有看過這兩個類的實現代碼，不過既然大家都這么說，那咱們這么記就行了，畢竟封裝性么，少操一點心也沒什麼不好。
但我還是覺得奇怪，畢竟要實現一個有序單鏈也不怎麼費勁。
㈨ java單向鏈表
java.util.Linkedlist是雙向鏈表，當然也就包括了單鏈表的功能，你可以去看他怎麼寫的啊
public class SingleLinkedList<E> {
private Entry<E> first, last;
private int size = 0;
public void add(E element) {
Entry<E> newEntry = new Entry<E>(element, null);
if (first == null) {
first = last = newEntry;
} else {
last.next = newEntry;
last = newEntry;
}
++size;
}
public E get(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = first;
for (int i = 0; i < index; ++i)
e = e.next;
return e.data;
}
private static class Entry<E> {
Entry(E data, Entry<E> next) {
this.data = data;
this.next = next;
}
E data;
Entry<E> next;
}
}