java实现链表代码 java如何实现链表

用Java语言实现单向链表

1.先定义一个节点类

创新互联公司成都网站建设定制设计，是成都网站营销推广公司,为凿毛机提供网站建设服务,有成熟的网站定制合作流程，提供网站定制设计服务：原型图制作、网站创意设计、前端HTML5制作、后台程序开发等。成都网站改版热线：18982081108

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 单链表基本操作的实现

/*

注意：链表的结点数量用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; i0 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; i0 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中如何实现双向链表?

双向链表：就是有双向指针，即双向的链域。\x0d\x0a链结点的结构：\x0d\x0a┌────┬────┬────────┐\x0d\x0a│ data │ next │ previous │\x0d\x0a└────┴────┴────────┘\x0d\x0a双向链表不必是双端链表(持有对最后一个链结点的引用)，双端链表插入时是双向的。\x0d\x0a有两条链：一条从头到尾，一条从尾到头，删除遍历时也是双向的。\x0d\x0a/**\x0d\x0a * 双向链表\x0d\x0a */\x0d\x0apublic class DoublyLinkedList {\x0d\x0a private Link head; //首结点\x0d\x0a private Link rear; //尾部指针\x0d\x0a public DoublyLinkedList() { }\x0d\x0a public T peekHead() {\x0d\x0a if (head != null) {\x0d\x0a return head.data;\x0d\x0a }\x0d\x0a return null;\x0d\x0a }\x0d\x0a public boolean isEmpty() {\x0d\x0a return head == null;\x0d\x0a }\x0d\x0a public void insertFirst(T data) {// 插入 到 链头\x0d\x0a Link newLink = new Link(data);\x0d\x0a if (isEmpty()) {//为空时，第1次插入的新结点为尾结点\x0d\x0a rear = newLink;\x0d\x0a } else {\x0d\x0a head.previous = newLink; //旧头结点的上结点等于新结点\x0d\x0a }\x0d\x0a newLink.next = head; //新结点的下结点旧头结点\x0d\x0a head = newLink; //赋值后，头结点的下结点是旧头结点，上结点null\x0d\x0a }\x0d\x0a public void insertLast(T data) {//在链尾 插入\x0d\x0a Link newLink = new Link(data);\x0d\x0a if (isEmpty()) {\x0d\x0a head = newLink;\x0d\x0a } else {\x0d\x0a rear.next = newLink;\x0d\x0a }\x0d\x0a newLink.previous = rear;\x0d\x0a rear = newLink; //赋值后，尾结点的上结点是旧尾结点，下结点null\x0d\x0a }\x0d\x0a public T deleteHead() {//删除 链头\x0d\x0a if (isEmpty()) return null;\x0d\x0a Link temp = head;\x0d\x0a head = head.next; //变更首结点，为下一结点\x0d\x0a if (head != null) {\x0d\x0a head.previous = null;\x0d\x0a } else {\x0d\x0a rear = null;\x0d\x0a }\x0d\x0a return temp.data;\x0d\x0a }\x0d\x0a public T deleteRear() {//删除 链尾\x0d\x0a if (isEmpty()) return null;\x0d\x0a Link temp = rear;\x0d\x0a rear = rear.previous; //变更尾结点，为上一结点\x0d\x0a if (rear != null) {\x0d\x0a rear.next = null;\x0d\x0a } else {\x0d\x0a head = null;\x0d\x0a }\x0d\x0a return temp.data;\x0d\x0a }\x0d\x0a public T find(T t) {//从头到尾find\x0d\x0a if (isEmpty()) {\x0d\x0a return null;\x0d\x0a }\x0d\x0a Link find = head;\x0d\x0a while (find != null) {\x0d\x0a if (!find.data.equals(t)) {\x0d\x0a find = find.next;\x0d\x0a } else {\x0d\x0a break;\x0d\x0a }\x0d\x0a }\x0d\x0a if (find == null) {\x0d\x0a return null;\x0d\x0a }\x0d\x0a return find.data;\x0d\x0a }\x0d\x0a public T delete(T t) {\x0d\x0a if (isEmpty()) {\x0d\x0a return null;\x0d\x0a }\x0d\x0a Link current = head;\x0d\x0a while (!current.data.equals(t)) {\x0d\x0a current = current.next;\x0d\x0a if (current == null) {\x0d\x0a return null;\x0d\x0a }\x0d\x0a }\x0d\x0a if (current == head) {\x0d\x0a head = head.next;\x0d\x0a if (head != null) {\x0d\x0a head.previous = null;\x0d\x0a }\x0d\x0a } else if (current == rear) {\x0d\x0a rear = rear.previous;\x0d\x0a if (rear != null) {\x0d\x0a rear.next = null;\x0d\x0a }\x0d\x0a } else {\x0d\x0a //中间的非两端的结点，要移除current\x0d\x0a current.next.previous = current.previous;\x0d\x0a current.previous.next = current.next;\x0d\x0a }\x0d\x0a return current.data;\x0d\x0a }\x0d\x0a public boolean insertAfter(T key, T data) {//插入在key之后, key不存在return false\x0d\x0a if (isEmpty()) {\x0d\x0a return false;\x0d\x0a }\x0d\x0a Link current = head;\x0d\x0a while (!current.data.equals(key)) {\x0d\x0a current = current.next;\x0d\x0a if (current == null) {\x0d\x0a return false;\x0d\x0a }\x0d\x0a }\x0d\x0a Link newLink = new Link(data);\x0d\x0a if (current == rear) {\x0d\x0a rear = newLink;\x0d\x0a } else {\x0d\x0a newLink.next = current.next;\x0d\x0a current.next.previous = newLink;\x0d\x0a }\x0d\x0a current.next = newLink;\x0d\x0a newLink.previous = current;\x0d\x0a return true;\x0d\x0a }\x0d\x0a public void displayList4Head() {//从头开始遍历\x0d\x0a System.out.println("List (first--last):");\x0d\x0a Link current = head;\x0d\x0a while (current != null) {\x0d\x0a current.displayLink();\x0d\x0a current = current.next;\x0d\x0a }\x0d\x0a }\x0d\x0a public void displayList4Rear() {//从尾开始遍历\x0d\x0a System.out.println("List (last--first):");\x0d\x0a Link current = rear;\x0d\x0a while (current != null) {\x0d\x0a current.displayLink();\x0d\x0a current = current.previous;\x0d\x0a }\x0d\x0a }\x0d\x0a\x0d\x0a class Link {//链结点\x0d\x0a T data; //数据域\x0d\x0a Link next; //后继指针，结点 链域\x0d\x0a Link previous; //前驱指针，结点 链域\x0d\x0a Link(T data) {\x0d\x0a this.data = data;\x0d\x0a }\x0d\x0a void displayLink() {\x0d\x0a System.out.println("the data is " + data.toString());\x0d\x0a }\x0d\x0a }\x0d\x0a public static void main(String[] args) {\x0d\x0a DoublyLinkedList list = new DoublyLinkedList();\x0d\x0a list.insertLast(1);\x0d\x0a list.insertFirst(2);\x0d\x0a list.insertLast(3);\x0d\x0a list.insertFirst(4);\x0d\x0a list.insertLast(5);\x0d\x0a list.displayList4Head();\x0d\x0a Integer deleteHead = list.deleteHead();\x0d\x0a System.out.println("deleteHead:" + deleteHead);\x0d\x0a list.displayList4Head();\x0d\x0a Integer deleteRear = list.deleteRear();\x0d\x0a System.out.println("deleteRear:" + deleteRear);\x0d\x0a list.displayList4Rear();\x0d\x0a System.out.println("find:" + list.find(6));\x0d\x0a System.out.println("find:" + list.find(3));\x0d\x0a System.out.println("delete find:" + list.delete(6));\x0d\x0a System.out.println("delete find:" + list.delete(1));\x0d\x0a list.displayList4Head();\x0d\x0a System.out.println("----在指定key后插入----");\x0d\x0a list.insertAfter(2, 8);\x0d\x0a list.insertAfter(2, 9);\x0d\x0a list.insertAfter(9, 10);\x0d\x0a list.displayList4Head();\x0d\x0a }\x0d\x0a}

. 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中如何创建一个链表？望能给我详细的代码。加点注释。谢谢

//如果感兴趣的话，可以把下面的改成泛型的也就是这样的

//一个学生的类

public class Stu(){

String name;

int age;

public Stu(String name,int age){

this.name=name;

this.age=age;

}

}

//创建两个学生的对像

Stu stu1=new Stu("weiwie",24);

Stu stu2=new Stu("xiaoqiang",25);

//创建集合类,存放的是Stu对像,这样的声明只能存Stu对像

List Stu list=new ArrayListStu();

//存数据

list.add(stu1);

list.add(stu2);

//遍历

for(int i=0;ilist.size();i++){

//向下转型方便了,取出来的就是Stu对像

Stu stu=list.get(i);

}

List list=new ArrayList();

list.add("对像");

遍历

for(int i=0;ilist.size();i++){

//需要强转

String str=(String)list.get(i);

得到你存放的数据

}

Map map=new HashMap();

//存值

map.put("one","对像");

//取值

String str=(String)map.get("one");

Set set=new HashSet();

//存值

set.add("对像");

//需要用这个对像遍历

Iterator iter=set.iterator();

while(iter.hasNext()){

//取值

String Str=(String)iter.next();

}