鏈表java實現。本站提示廣大學習愛好者：（鏈表java實現）文章只能為提供參考，不一定能成為您想要的結果。以下是鏈表java實現正文
鏈表是用指針將多個節點聯系在一起，通過頭節點和尾節點還有節點數量，可以對鏈表進行一系列的操作。是線性表的鏈式存儲實現。
1.鏈表是多個不連續的地址組成在一起根據指針鏈接在一起的，由多個節點組成，每個節點包括元素域和指針域
2.元素域存儲節點數組，指針域存儲下一節點指針
3.我們對鏈表的操作都是間接的通過鏈表頭節點操作來實現的
4.一個鏈表中有多個節點，一個節點包括元素域，和下一節點指針域
5.最左邊的節點是頭節點，但是添加節點是從右到左添加，新添加的節點會被作為頭節點
6.鏈表是由不定數量的節點連接（通過相互之間的引用）起來的，由於這種關系，在鏈表裡我們只定義了頭節點和節點數量。節點是由存儲的對象及對下一個“節點”的引用封裝而成。
7.在添加節點到鏈表中時，首先添加的節點後置後，新添加的節點作為頭節點引用前一個添加的節點。
//先創建一個節點類
1 package linkedList;
2 //節點類
3 public class Node<E> {
4 protected Object data = null; //數據域
5 protected Node<E> next = null; //指針域
6
7 //初始化數據域
8 public Node(E e, Node<E> next) {
9 this.data = e; //初始化數據域
10 this.next = next; //初始化指針域
11 }
12
13 //顯示節點，獲取當前實體對象,數據域
14 public Object getData(){
15 return this.data;
16 }
17
18 //獲取下一個實體，指針域
19 public Node<E> getNext(){
20 return this.next;
21 }
22
23 @Override
24 public String toString() {
25 return "Node [data=" + data + ", next=" + next + "]";
26 }
27
28 }
//然後創建我們的鏈表類，將節點作為鏈表的屬性
1 package linkedList;
2
3 import java.util.ArrayList;
4 import java.util.List;
5
6 /**
7 * 1.鏈表是多個不連續的地址組成在一起根據指針鏈接在一起的，由多個節點組成，每個節點包括元素域和指針域
8 * 2.元素域存儲節點數組，指針域存儲下一節點指針
9 * 3.我們對鏈表的操作都是間接的通過鏈表頭節點操作來實現的
10 * 4.一個鏈表中有多個節點，一個節點包括元素域，和下一節點指針域
11 * 5.最左邊的節點是頭節點，但是添加節點是從右到左添加，新添加的節點會被作為頭節點
12 * 6.鏈表是由不定數量的節點連接（通過相互之間的引用）起來的，由於這種關系，在鏈表裡我們只定義了頭節點和節點數量。節點是由存儲的對象及對下一個“節點”的引用封裝而成。
13 * 7.在添加節點到鏈表中時，首先添加的節點後置後，新添加的節點作為頭節點引用前一個添加的節點。
14 * @author LH-PC
15 *
16 */
17 public class LinkedList<E> implements java.io.Serializable{
18 private static final long serialVersionUID = 1L;
19
20 private Node<E> head; //頭節點
21 private int size; //節點數量，即鏈表長度
22
23
24 //添加頭節點 在添加鏈表節點時，首先添加的節點(頭節點)後置，新添加的節點變成頭節點，並且執向前一個頭節點
25 public void addNode(E e){
26 //判斷鏈表中有無該對象:從頭節點開始遍歷，匹配有無此對象
27 //如果有頭節點，則添加新的節點為頭節點，新的頭節點指向上一個頭節點
28 if(head != null){
29 System.out.println("鏈表中已經存在頭節點, 正在添加新的頭節點:" + e);
30 System.out.println("添加成功! 此頭節點指向->" + head.data);
31 this.head = new Node<E>(e, head); //將新添加的節點作為頭節點，指針域指向上一個頭節點
32 size ++; //節點數量++
33
34 }else {
35 //如果沒有頭節點，則添加新的對象作為頭節點，第一個頭節點指向null
36 System.out.println("鏈表中不存在頭節點，正在添加頭節點:" + e);
37 this.head = new Node<E>(e, null);
38 System.out.println("添加成功！頭節點指向->" + null);
39 size ++; //節點數量++
40 }
41 }
42
43 //在指定位置插入節點
44 public int insert(int index, E e){
45 Node<E> temp = this.head;
46 int i = 0;
47 if(index < i || i > this.size){
48 System.err.println("索引大於鏈表長度或者小於0:" + index);
49 return -1;
50 }
51
52 if(index == 0){
53 //如果index == 0,插入到頭節點之後
54 this.head.next = new Node<E>(e, head.next); //將頭節點指向新節點,將新節點指向原來頭節點的下一個節點
55 size ++; //節點數量加1
56 return 1;
57 }
58
59 //遍歷鏈表
60 while(temp != null){
61 //運動到了指定位置
62 if(index == i){
63 temp.next = new Node<E>(e, temp.next); //將插入進來的指針域指向當前節點,將當前節點的上一個節點指針域指向當前節點
64 size ++; //節點長度加1
65 break;
66 }
67 temp = temp.next; //向下一個節點運動
68 i ++;
69 }
70
71 return 1;
72 }
73
74 //刪除頭節點
75 public void deleteByHead(){
76 //1.找到頭節點。this.head
77 //2.更新頭節點。將當前鏈表頭節點設置為刪除頭節點的指針域
78 //3.鏈表節點數量-1
79 System.out.println("正在刪除頭節點:" + this.head.getData());
80 this.head = this.head.next; //更新頭節點為下一節點
81 size --; //節點數量-1
82 System.out.println("刪除成功");
83
84 }
85
86 //刪除指定位置的節點
87 public void deleteByIndex(int index){
88 //找到指定位置的前一個節點，將前一個節點指向後面兩個節點。中間的節點就將被刪除了。
89 Node<E> temp = this.head;
90 int i = 0;
91 if(index < i || index > this.size){
92 System.err.println("索引不能小於0或大於鏈表長度:" + index);
93 return;
94 }
95
96 //如果索引為0，表示刪除頭節點
97 if( index == 0){
98 this.deleteByHead(); //調用刪除頭節點方法
99 return;
100 }
101
102 //遍歷鏈表
103 while(temp != null){
104 //找到目標節點的上一個節點
105 if(index-1 == i){
106 System.out.println("正在刪除節點:" + this.head.next.getData());
107 temp.next = temp.next.next;
108 System.out.println("刪除成功");
109 size --; //節點數減1
110 return;
111 }
112 temp = temp.next; //繼續遍歷
113 i ++;
114 }
115
116 }
117
118 //更新指定位置的節點
119 public void updateByIndex(int index, E e){
120 if(index < 0 || index > this.size){
121 System.err.println("索引小於0或者大於鏈表長度:" + index);
122 }
123
124 // if(index == 0){
125 // this.updateByHead(e); //如果index==0,更新頭節點
126 // }
127
128 //遍歷鏈表
129 int i = 0;
130 Node<E> temp = this.head;
131 while(temp != null){
132 if(index == i){
133 temp.data = e;
134 break;
135 }
136 temp = temp.next;
137 i ++;
138 }
139
140 }
141
142 //更新頭節點
143 public void updateByHead(E e){
144 this.head.data = e; //為頭節點重新賦值
145 }
146
147 //打印鏈表中的所有數據 從頭節點一直到尾節點。 (1).head (2).head.next (3).head.next.next (n).head.next.n.n
148 public void display(){
149 Node<E> temp = this.head;
150 //從頭節點開始遍歷到為尾節點
151 while(temp != null){
152 System.out.println(temp.getData());
153 temp = temp.next; //指向下一節點。
154 }
155 }
156
157 //返回鏈表list
158 public List<Node<E>> findAll(){
159 List<Node<E>> list = new ArrayList<Node<E>>();
160 Node<E> temp = this.head;
161 while(temp != null){
162 list.add(temp);
163 temp = temp.next;
164 }
165 return list;
166 }
167
168 //查找指定位置結點
169 public Node<E> findByIndex(int index){
170 Node<E> temp = this.head;
171 int i = 0;
172
173 //參數校驗，返回null
174 if(index < i || index > this.size){
175 System.err.println("參數大於鏈表長度或者小於0:" + index);
176 return null;
177 }
178
179 //如果index == 0,返回頭節點
180 if(index == 0){
181 return this.head; //如果下標為1，直接返回頭節點
182 }
183
184 //遍歷鏈表進行匹配
185 while(temp != null){
186 if(i == index){
187 return temp; //匹配節點
188 }
189 temp = temp.next; //繼續遍歷
190 i ++;
191 }
192 return null;
193 }
194
195 //獲得鏈表節點數量
196 public int getSize(){
197 return this.size;
198 }
199
200 //獲取當前頭節點
201 public Node<E> getHead(){
202 return this.head;
203 }
204
205 //測試我的鏈表
206 public static void main(String[] args) {
207 LinkedList<Integer> linkedList = new LinkedList<Integer>();
208
209 //添加節點
210 linkedList.addNode(1);
211 linkedList.addNode(2);
212 linkedList.addNode(3);
213 linkedList.addNode(4);
214 linkedList.addNode(5);
215 linkedList.addNode(6);
216
217 linkedList.insert(6, 9);
218 linkedList.updateByIndex(6, 9);
219 linkedList.display();
220
221 }
222
223 }
