双向链表怎么写

java怎么写链表

1.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 。

2.Java写链表结构如何在一个node里写多个数据

java 泛型不支持int 必须进行包装转成Integer

//你们老师那个能运行？

public class LinkedPriorityList<E> {

Node<E> head;

Node<E> last;

public void addNode(E date) {

if(head==null){

head=new Node<E>(date);

last=head;

}else {

last.next=new Node<E>(date);

last=last.next;

}

}

public void Iterator() {

Node<E> temp=head;

while (true) {

System.out.println(temp.data);

if(temp.next==null){

break;

}

temp=temp.next;

}

}

public static void main(String[] args) {

//LinkedPriorityList<String> lpList=new LinkedPriorityList<String>();

//如果要泛型支持不同数据类型，不写<String>；就行

LinkedPriorityList lpList=new LinkedPriorityList();

lpList.addNode("bac");

lpList.addNode("cdd");

lpList.addNode("3234");

lpList.addNode(21);

lpList.addNode('e');

lpList.Iterator();

}

}

class Node<E>{

E data;

Node<E> next;

Node(E date){

this.data=date;

}

}

3.java 链表

class Node { Object data; Node next；//申明类Node类的对象叫Next public Node(Object data) { //类Node的构造函数 setData(data); } public void setData(Object data) { this.data = data; } public Object getData() { return data; } } class Link { Node head；//申明一个Node类的一个对象 head int size = 0; public void add(Object data) { Node n = new Node(data)； //调用Node类的构造函数链表是一种重要的数据结构，在程序设计中占有很重要的地位。

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; } }。

4.求一个JAVA的单链表程序

package OS;

public class IntNode

{

public String name;

//public int run_time=44;

public int run_time=(int)(Math.random()*100);

public IntNode next;

public int num;

public IntNode(int n,String n1){

this(n,n1,null);

}

public IntNode(int n,String n1,IntNode nn){

num=n;

name=n1;

next=nn;

}

}

package OS;

public class IntSLList

{

public IntNode head；//头尾“指针”

public IntNode tail;

public IntSLList(){

head=tail=null;

}

//判别链表是否为空

public boolean isEmpty(){

return head==null;

}

//从链表头部添加结点————此处的函数的传递参数是一个数值，也就是info

public void addToHead(IntNode some){

some.next=head;

head=some;

if(tail==null)

tail=head;

}

//从链表的尾部添加结点————同上

public void addToTail(IntNode some){

if(!isEmpty())

{

tail.next=some;

tail=tail.next;

}

else

head=tail=some;

}

//从链表头开始删除

public void deleteFromHead(){

if(head==tail)

head=tail=null;

else{

head=head.next;

}

}

}

5.如何使用Java实现单链表

首先构建节点类： package com。

fzw。sf; public class Node { private Object data; private Node next; Node(Object data,Node next){ this。

data = data; this。next = next; } public Object getData() { return data; } public void setData(Object data) { this。

data = data; } public Node getNext() { return next; } public void setNext(Node next) { this。next = next； } } 其次，构建单链表类： package com。

fzw。sf; public class List4j { private Node head ; private int length; public List4j(){ head = new Node(null,null); length = 0; } public void addhead(Object item){ Node node = new Node(item,null); node。

setNext(head。getNext()); head。

setNext(node); length++; } public void addtail(Object item){ Node node = new Node(item,null); Node temp = head; while(null != temp。 getNext()){ temp = temp。

getNext(); } temp。setNext(node); length++; } public void addindex(Object item,int index){ Node node = new Node(item,null)。

6.帮用JAVA编个程序 运用到链表

public class Player {

private Player previous;

private Player next;

private int number;

private static int instanceCount;

public Player() {

number = ++instanceCount;

}

public int getNumber() {

return number;

}

private void detach() {

if (this.previous == this.next) {

this.previous.next = null;

this.next.previous = null;

return;

}

if (this.previous != null)

this.previous.next = this.next;

if (this.next != null)

this.next.previous = this.previous;

}

public Player nextPlayer() {

Player player = new Player();

player.previous = this;

this.next = player;

return player;

}

public int post(int position) {

if (position == 7) {

position = 0;

detach();

}

if (next != null) {

return next.post(position + 1);

} else {

return number;

}

}

public static void main(String[] args) {

Player first = new Player();

Player cur = first;

for (int i = 0; i

7.用JAVA编写链表类,要求编写能够从头部添加节点

public class ZLinkedList {

private int size;

private Node head;

public ZLinkedList(){

size = 0;

}

public void headInsert(Object obj){

//if(null== obj) {// do something}

Node temp = new Node(obj);

if(size ==0){

head = temp;

}else{

temp.setNext(head);

head = temp;

}

size++;

}

public void preOrder(){

int length = size;

Node temp = head;

for(int i= 0;i

转载请注明出处育才学习网 » 双向链表怎么写