Java实现节点链表

参考

链结点  

   在链表中，每个数据项都被包含在‘点“中，一个点是某个类的对象，这个类可认叫做 

   LINK。因为一个链表中有许多类似的链结点，所以有必要用一个不同于链表的类来表达 

   链结点。每个 LINK 对象中都包含一个对下一个点引用的字段（通常叫做 next）但是

   本身的对象中有一个字段指向对第一个链结点的引用  

 

 

 

单链表是一种顺序存取的结构，为找第 i个数据元素，必须先找到第 i-1个数 

据元素。因此，查找第i个数据元素的基本操作为：移动指针，比较  j                     和  i 

 

    1、链接存储方法 

 

    链接方式存储的线性表简称为链表（LinkedList ）。 

 

    链表的具体存储表示为： 

 

    ① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的， 

 

也可以是不连续的） 

 ② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻 

 

辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信 

 

息（称为指针（pointer ）或链(link) ） 

 

    注意： 

 

    链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示 

 

各种非线性的数据结构。 

 

    2 、链表的结点结构 

 

     ┌──┬──┐ 

 

     │data │next │ 

 

     └──┴──┘ 

 

    data 域--存放结点值的数据域 

 

    next 域--存放结点的直接后继的地址（位置）的指针域（链域） 

 

    注意： 

 

    ①链表通过每个结点的链域将线性表的 n 个结点按其逻辑顺序链接在一起的。 

 

    ②每个结点只有一个链域的链表称为单链表（Single                         Linked  List ）。 

 

 

    3 、头指针 head 和终端结点指针域的表示 

 

    单链表中每个结点的存储地址是存放在其前趋结点 next 域中，而开始结点无前 

 

趋，故应设头指针 head 指向开始结点。 

 

    注意： 

 

    链表由头指针唯一确定，单链表可以用头指针的名字来命名。 

 

    【例】头指针名是 head 的链表可称为表 head 。 

 

    终端结点无后继，故终端结点的指针域为空，即 NULL 。

 

 

 

[java]  view plain  copy

 print ?

1. public class LinkList {  
2.   
3.     public class Node{  //定义节点  
4.         private T data;  
5.         private Node next;  
6.         public Node(){  
7.               
8.         }  
9.         public Node(T data,Node next){  
10.             this.data=data;  
11.             this.next=next;  
12.         }  
13.     }  
14.       
15.     private Node header;//头节点  
16.     private Node tail;//尾节点  
17.     private int size;//链表大小  
18.       
19.      
20.     //构造函数初始化数据  
21.     public LinkList(){  
22.         header=null;  
23.         tail=null;  
24.     }  
25.     public LinkList(T element){  
26.         header=new Node(element,null);  
27.         tail=header;  
28.         size++;  
29.     }  
30.       
31.     //链表长度  
32.     public int length(){  
33.         return size;  
34.     }  
35.       
36.     //返回指定位置index的节点  
37.     public T get(int index){  
38.         return getNodeByIndex(index).data;  
39.     }  
40.       
41.     private Node getNodeByIndex(int index) {  
42.         if(index<</span>0||index>size-1){  
43.             throw new IndexOutOfBoundsException("线性表索引越界");  
44.         }  
45.         Node current=header;  
46.         for(int i=0;inull;i++,current=current.next){  
47.             if(i==index){  
48.                 return current;  
49.             }  
50.         }  
51.         return null;  
52.     }  
53.       
54.     //返回element在链表的位置，-1表示不存在  
55.     public int locate(T element){  
56.         Node current=header;  
57.         for(int i=0;inull;i++,current=current.next){  
58.             if(current.data==element){  
59.                 return i;  
60.             }  
61.         }  
62.         return -1;  
63.     }  
64.       
65.       
66.     //在index位置插入节点element  
67.     public void insert(T element,int index){  
68.         if(index<</span>0||index>size){  
69.             throw new IndexOutOfBoundsException("线性表索引越界");  
70.         }  
71.         if(header==null){  
72.             add(element);  
73.         }else{  
74.             if(index==0){  
75.                 addAtHeader(element);  
76.             }else{  
77.                 Node prev=getNodeByIndex(index-1);  
78.                 prev.next=new Node(element,prev.next);  
79.                 size++;  
80.             }  
81.         }  
82.     }  
83.       
84.     //采用尾插法为链表添加新节点  
85.     private void add(T element) {  
86.         // TODO Auto-generated method stub  
87.         if(header==null){  
88.             header=new Node(element,null);  
89.             tail=header;  
90.         }else{  
91.             Node newNode=new Node(element,null);  
92.             tail.next=newNode;  
93.             tail=newNode;  
94.         }  
95.         size++;  
96.     }  
97.       
98.     //采用头插法为链表添加新节点  
99.     private void addAtHeader(T element){  
100.         header=new Node(element,header);  
101.         if(tail==null){  
102.             tail=header;  
103.         }  
104.         size++;  
105.     }  
106.       
107.     //删除index位置的节点  
108.     public T delete(int index){  
109.         if(index<</span>0||index>size-1){  
110.             throw new IndexOutOfBoundsException("线性表索引越界");  
111.         }  
112.         Node del=null;  
113.         if(index==0){  
114.             del=header;  
115.             header=header.next;  
116.         }else{  
117.             Node prev=getNodeByIndex(index-1);  
118.             del=prev.next;  
119.             prev.next=del.next;  
120.             del.next=null;  
121.         }  
122.         size--;  
123.         return del.data;  
124.     }  
125.       
126.     //从链表后面删除一个节点  
127.     public T remove(){  
128.         return delete(size-1);  
129.     }  
130.       
131.     //是否为空  
132.     public boolean empty(){  
133.         return size==0;  
134.     }  
135.     //清空链表  
136.     public void clear(){  
137.         header=null;  
138.         tail=null;  
139.         size=0;  
140.     }  
141.       
142.     public String toString(){  
143.         if(empty()){  
144.             return "[]";  
145.         }else{  
146.             StringBuilder sb=new StringBuilder("[");  
147.             for(Node current=header;current!=null;current=current.next){  
148.                 sb.append(current.data.toString()+", ");  
149.             }  
150.             int len=sb.length();  
151.             return sb.delete(len-2, len).append("]").toString();  
152.         }  
153.     }  
154.     public static void main(String[] args) {  
155.         LinkList list=new LinkList();  
156.         list.insert("aaa", 0);  
157.         list.add("bbb");  
158.         list.add("ccc");  
159.         System.out.println(list.toString());  
160.         list.insert("ddd", 1);  
161.         System.out.println(list.toString());  
162.         list.delete(2);  
163.         System.out.println(list.toString());  
164.         System.out.println("ccc在链表中的位置："+list.locate("ccc"));  
165.         System.out.println("链表中索引2处的元素："+list.get(2));  
166.     }  
167.   
168. }