『壹』 求java 單鏈表基本操作的實現
/*
注意：鏈表的結點數量用size表示，結點的位置為0~size-1
*/
import java.util.Scanner;
public class Test7 {
public static void main(String[] args) {
try{
LinkList list = new LinkList();
Integer value;
int pos = 0;
Scanner input = new Scanner(System.in);
String choice = null;
//測試A
while(true){
System.out.print("請輸入待插入結點的值(x或X退出)：");
choice = input.next();
if(choice.toUpperCase().equals("X")){
break;
}
value = Integer.valueOf(choice);
if(list.addAt(pos, value) == true){
System.out.println("插入值為 " + value + " 的結點到當前鏈表成功!");
pos++;
}
else{
System.out.println("插入結點失敗!");
}
}
System.out.print("當前鏈表所有結點：");
list.listAll();
//測試B
while(true){
System.out.print("請輸入待查詢結點的值(x或X退出)：");
choice = input.next();
if(choice.toUpperCase().equals("X")){
break;
}
value = Integer.valueOf(choice);
pos = list.findByValue(value);
if(pos == -1){
System.out.println("當前鏈表中不存在值為 " + value + " 的結點");
}
else{
System.out.println("值為 " + value + " 的結點在當前鏈表中的位置為 " + pos);
}
}
//測試C
while(true){
System.out.print("請輸入待刪除結點的位置[0~" + (list.getSize()-1) + "](x或X退出)：");
choice = input.next();
if(choice.toUpperCase().equals("X")){
break;
}
pos = Integer.valueOf(choice);
if(list.removeAt(pos) == true){
System.out.println("刪除當前鏈表中 " + pos + " 位置的結點成功!");
}
else{
System.out.println("刪除結點失敗!");
}
}
System.out.print("當前鏈表所有結點：");
list.listAll();
}
catch(Exception e){
e.printStackTrace();
}
}
}
/**
* 鏈表結點類
*/
class Node{
private Object data; //鏈表結點的數據域
private Node next; //鏈表結點的指針域，指向直接後繼結點
public Node(){
data = null;
next = null;
}
public Node(Object data, Node next){
this.data = data;
this.next = next;
}
public Object getData(){
return this.data;
}
public void setData(Object data){
this.data = data;
}
public Node getNext(){
return this.next;
}
public void setNext(Node next){
this.next = next;
}
}
/**
* 鏈表類
*/
class LinkList{
private Node head = null; //頭結點指針
private int size = 0;
public LinkList(){
head = new Node();
size = 0;
}
//在i位置插入元素elem
public boolean addAt(int i, Object elem) {
if(i < 0 || i > size){
return false;
}
Node pre,curr;
int pos;
for(pre=head; i>0 && pre.getNext()!=null; i--,pre=pre.getNext());
curr = new Node(elem, pre.getNext());
pre.setNext(curr);
size++;
return true;
}
//刪除i位置的元素
public boolean removeAt(int i) {
if(i < 0 || i >= size){
return false;
}
Node pre,curr;
for(pre=head; i>0 && pre.getNext()!=null; i--,pre=pre.getNext());
curr = pre.getNext();
pre.setNext(curr.getNext());
size--;
return true;
}
//根據值value查詢結點是否存在，若存在返回位置，否則返回-1
public int findByValue(Object value){
Node curr;
int pos;
for(pos=0,curr=head.getNext(); curr!=null; pos++,curr=curr.getNext()){
if(curr.getData().toString().equals(value.toString())){
break;
}
}
if(curr==null){
return -1;
}
return pos;
//return (curr!=null ? pos : -1);
}
public int getSize(){
return size;
}
public boolean isEmpty(){
return (size==0);
}
public void listAll(){
for(Node curr=head.getNext(); curr!=null; curr=curr.getNext()){
System.out.print(curr.getData() + "\t");
}
System.out.println();
}
}
『貳』 . java怎麼創建鏈表
java中創建鏈表的例子：
package zx;
class Link{
private Node root;
class Node{
private String name;
private Node Next;
public Node(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void addNode(Node newNode){
if(this.Next==null){
this.Next = newNode;
}else{
this.Next.addNode(newNode);
}
}
public void printNode(){
System.out.print(this.name + "-->");
if(this.Next!=null){
this.Next.printNode();
}
}
};
public void add(String name){
Node newNode = new Node(name);
if(this.root==null){
this.root = newNode;
}else{
this.root.addNode(newNode);
}
}
public void print(){
if(this.root!=null){
this.root.printNode();
}
}
};
public class LinkDemo {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Link link = new Link();
link.add("根節點");
link.add("第一節點");
link.add("第二節點");
link.add("第三節點");
link.add("第四節點");
link.print();
System.out.println("null");
}
}
『叄』 JAVA單鏈表中結點類用private修飾,怎麼用在鏈表類里
在Java單鏈表中，節點類通常包含兩個屬性：一個存儲數據的變數和一個指向下一個節點談兄皮的變數。為了保證數據的封裝性，通常會將這兩個屬性都用private修飾，然後提供對應的getter和setter方法含差來訪問和修改這些屬性。
下面是一個簡單的Java單鏈表節點類示例：
public class ListNode {
private int val;
private ListNode next;
public ListNode(int val) {
this.val = val;
}
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
public ListNode getNext() {
return next;
}
public void setNext(ListNode next) {
this.next = next;
}
}
在鏈表類中，我們需要創建一個頭節點來表示整個鏈表的起始位置。可以將鏈表類的定義如下：
public class LinkedList {
private ListNode head;
public LinkedList() {
this.head = null;
}
// 添加節點到鏈表尾部
public void addNode(int val) {
ListNode newNode = new ListNode(val);
if (head == null) {
head = newNode;
} else {
ListNode cur = head;
while (cur.getNext() != null) {
cur = cur.getNext();
}
cur.setNext(newNode);
}
}
// 遍歷鏈表並輸出節點值
public void traverse() {
ListNode cur = head;
while (cur != null) {
System.out.print(cur.getVal() + " ");
cur = cur.getNext();
}
System.out.println();
}
}
在鏈表類中，我們將head屬性也用private修飾，並提供對應的getter和setter方法來訪問和修改head屬性。在addNode方法中，我們首先判斷鏈表是否為空，如果為空，直接將新節點作為頭節點；否則，遍歷鏈表找到尾節點並將新節點接在其後面。在traverse方法中，我們遍歷整個鏈表並輸出每個節點的值。
使用時，可以創建一個新的LinkedList對象，然後調用其addNode方法添加節點，最後調塵和用traverse方法遍歷鏈表並輸出每個節點的值。例如：
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.addNode(1);
list.addNode(2);
list.addNode(3);
list.traverse();
}
這段代碼會輸出：1 2 3。
『肆』 java中鏈表是指java.util包中的LinkedList類嗎
鏈表斗鉛襪指的是一種數空激激穗據存儲結構，java.util.LinkedList是JAVA自己實現的一個雙向鏈表，自定義鏈表的話可以參考LinkedList類的源碼
『伍』 JAVA 鏈表問題
while (current != null);
{
【在這里提示拿悉current只能為空指針】b.add(current.data);
current = current.next;
}
你的while循環後慶敏納面多了一個分號，導致while循環是一個空譽沒實現，而後面的是一個代碼塊而已
『陸』 java 中什麼是鏈表,鏈表結構有什麼好處。
比如linkedlist,鏈表的好處是刪除快，但是在增添的時候速度慢，普通arraylist，linklist,10w個以上數據的讀寫中就比較容易看出速度上的差別了。 arraylist是普通數組，在刪除時要移位，數量級大的情況下速度非常慢。linkedlist在java實現中應為模擬鏈表結構，在添加操作時增加了很多運算次數，但是刪除時不需要移位，只需要重新標記地址，所以刪除比較快。
以上為例子，其實基於鏈表的集合還有不少，java方便的提供了很多api，其實數據結構都是一樣的，無論是哪個語言實現。
『柒』 java如何實現鏈表
鏈表是一種重要的數據結構，在程序設計中佔有很重要的地位。C語言和C＋＋語言中是用指針來實現鏈表結構的，由於Java語言不提供指針，所以有人認為在Java語言中不能實現鏈表，其實不然，Java語言比C和C＋＋更容易實現鏈表結構。Java語言中的對象引用實際上是一個指針（本文中的指針均為概念上的意義，而非語言提供的數據類型），所以我們可以編寫這樣的類來實現鏈表中的結點。
class Node
{
Object data;
Node next;//指向下一個結點
}
將數據域定義成Object類是因為Object類是廣義超類，任何類對象都可以給其賦值，增加了代碼的通用性。為了使鏈表可以被訪問還需要定義一個表頭，表頭必須包含指向第一個結點的指針和指向當前結點的指針。為了便於在鏈表尾部增加結點，還可以增加一指向鏈表尾部的指針，另外還可以用一個域來表示鏈表的大小，當調用者想得到鏈表的大小時，不必遍歷整個鏈表。下圖是這種鏈表的示意圖：
鏈表的數據結構
我們可以用類List來實現鏈表結構，用變數Head、Tail、Length、Pointer來實現表頭。存儲當前結點的指針時有一定的技巧，Pointer並非存儲指向當前結點的指針，而是存儲指向它的前趨結點的指針,當其值為null時表示當前結點是第一個結點。那麼為什麼要這樣做呢？這是因為當刪除當前結點後仍需保證剩下的結點構成鏈表，如果Pointer指向當前結點，則會給操作帶來很大困難。那麼如何得到當前結點呢，我們定義了一個方法cursor(),返回值是指向當前結點的指針。類List還定義了一些方法來實現對鏈表的基本操作，通過運用這些基本操作我們可以對鏈表進行各種操作。例如reset()方法使第一個結點成為當前結點。insert(Object d)方法在當前結點前插入一個結點，並使其成為當前結點。remove()方法刪除當前結點同時返回其內容，並使其後繼結點成為當前結點，如果刪除的是最後一個結點，則第一個結點變為當前結點。
鏈表類List的源代碼如下：
import java.io.*;
public class List
{
/*用變數來實現表頭*/
private Node Head=null;
private Node Tail=null;
private Node Pointer=null;
private int Length=0;
public void deleteAll()
/*清空整個鏈表*/
{
Head=null;
Tail=null;
Pointer=null;
Length=0;
}
public void reset()
/*鏈表復位，使第一個結點成為當前結點*/
{
Pointer=null;
}
public boolean isEmpty()
/*判斷鏈表是否為空*/
{
return(Length==0);
}
public boolean isEnd()
/*判斷當前結點是否為最後一個結點*/
{
if(Length==0)
throw new java.lang.NullPointerException();
else if(Length==1)
return true;
else
return(cursor()==Tail);
}
public Object nextNode()
/*返回當前結點的下一個結點的值，並使其成為當前結點*/
{
if(Length==1)
throw new java.util.NoSuchElementException();
else if(Length==0)
throw new java.lang.NullPointerException();
else
{
Node temp=cursor();
Pointer=temp;
if(temp!=Tail)
return(temp.next.data);
else
throw new java.util.NoSuchElementException();
}
}
public Object currentNode()
/*返回當前結點的值*/
{
Node temp=cursor();
return temp.data;
}
public void insert(Object d)
/*在當前結點前插入一個結點，並使其成為當前結點*/
{
Node e=new Node(d);
if(Length==0)
{
Tail=e;
Head=e;
}
else
{
Node temp=cursor();
e.next=temp;
if(Pointer==null)
Head=e;
else
Pointer.next=e;
}
Length＋＋;
}
public int size()
/*返回鏈表的大小*/
{
return (Length);
}
public Object remove()
/*將當前結點移出鏈表，下一個結點成為當前結點，如果移出的結點是最後一個結點，則第一個結點成為當前結點*/
{
Object temp;
if(Length==0)
throw new java.util.NoSuchElementException();
else if(Length==1)
{
temp=Head.data;
deleteAll();
}
else
{
Node cur=cursor();
temp=cur.data;
if(cur==Head)
Head=cur.next;
else if(cur==Tail)
{
Pointer.next=null;
Tail=Pointer;
reset();
}
else
Pointer.next=cur.next;
Length－－;
}
return temp;
}
private Node cursor()
/*返回當前結點的指針*/
{
if(Head==null)
throw new java.lang.NullPointerException();
else if(Pointer==null)
return Head;
else
return Pointer.next;
}
public static void main(String[] args)
/*鏈表的簡單應用舉例*/
{
List a=new List ();
for(int i=1;i<=10;i＋＋)
a.insert(new Integer(i));
System.out.println(a.currentNode());
while(!a.isEnd())
System.out.println(a.nextNode());
a.reset();
while(!a.isEnd())
{
a.remove();
}
a.remove();
a.reset();
if(a.isEmpty())
System.out.println("There is no Node in List \n");
System.in.println("You can press return to quit\n");
try
{
System.in.read();
//確保用戶看清程序運行結果
}
catch(IOException e)
{}
}
}
class Node
/*構成鏈表的結點定義*/
{
Object data;
Node next;
Node(Object d)
{
data=d;
next=null;
}
}
讀者還可以根據實際需要定義新的方法來對鏈表進行操作。雙向鏈表可以用類似的方法實現只是結點的類增加了一個指向前趨結點的指針。
可以用這樣的代碼來實現：
class Node
{
Object data;
Node next;
Node previous;
Node(Object d)
{
data=d;
next=null;
previous=null;
}
}
當然，雙向鏈表基本操作的實現略有不同。鏈表和雙向鏈表的實現方法，也可以用在堆棧和隊列的實現中，這里就不再多寫了，有興趣的讀者可以將List類的代碼稍加改動即可。
希望對你有幫助。
『捌』 JAVA中鏈表有什麼用
java中的List介面 中有兩個實現類：ArrayList和LinkedList。前者是使用數組實現，用索引來取數據是它的優勢。後者是用雙向鏈表實現，在插入和刪除操作上占優勢。具體實現已經封裝好了，不用操心過多，具體動作都有具體的方法。