My_Single_LinkedList
分4个部分实现（CRUD - 增删改查）。
首先要有一个Node（节点类）
1 class Node {
2 public int val;
3 public Node next;
4
5 public Node(int val) {
6 this.val = val;
7 this.next = null;
8 }
9 }
instance variables and constructer - 成员变量和构造函数
1 public Node head; //头指针指向虚拟的node，真正的list是取head.next
2 public Node last; //尾指针指向最后一个元素
3 public int length; //list的长度，不是index。在insert的时候，判断insert的index
4
5 public My_Single_LinkedList() {
6 this.head = new Node(-1);
7 this.last = head;
8 this.length = 0;
9 }
1. 添加
添加部分有两大部分，一个是添加在头和尾，一个是添加在某个index的左和右。
添加的同时要保持length和last指针的更新
1) 添加在头和尾：O(1)的时间复杂度
1 public void addLast(int val) {
2 last.next = new Node(val);
3 last = last.next;
4 this.length++;
5 }
6
7 public void addFirst(int val) {
8 Node newNode = new Node(val);
9 newNode.next = head.next;
10 head.next = newNode;
11 this.length++;
12 }
2) 在某个index的左和右添加：O(n)时间复杂度
1 /**
2 * insert before index
3 * @param val
4 * @param index
5 */
6 public void insertBefore(int val, int index) {
7 if (index <= 0) { //在0之前加，相当于addFirst
8 addFirst(val);
9 return;
10 }
11 if (index >= length) {//在超出length之前加，相当于addLast
12 addLast(val);
13 return;
14 }
15 // 普通情况，两个指针，一前一后
16 Node cur = head.next;
17 Node prev = head;
18 int counter = 0;
19 while (cur != null && counter < index) {
20 cur = cur.next;
21 prev = prev.next;
22 counter++;
23 }
24 Node newNode = new Node(val);
25 newNode.next = cur;
26 prev.next = newNode;
27 this.length++;
28 }
29
30 /**
31 * insert after index
32 * @param val
33 * @param index certain index you want to insert at
34 */
35 public void insertAfter(int val, int index) {
36 if (index < 0) {
37 addFirst(val);
38 return;
39 }
40 if (index >= length - 1) {
41 addLast(val);
42 return;
43 }
44 Node cur = head.next;
45 int counter = 0;
46 while (cur != null && counter < index) {
47 cur = cur.next;
48 counter++;
49 }
50 Node newNode = new Node(val);
51 newNode.next = cur.next;
52 cur.next = newNode;
53 this.length++;
54 }
2. 更新：O(n)时间复杂度
1 public void updateAt(int val, int index) {
2 if (index < 0 || index > length - 1) {
3 return;
4 }
5 int counter = 0;
6 Node cur = head.next;
7 while (cur != null && counter < index) {
8 cur = cur.next;
9 counter++;
10 }
11 cur.val = val;
12 }
3. 删除：O(n)时间复杂度
删除的时候也要注意length和last的更新
1 public void deleteAt(int index) {
2 if (index < 0 || index > length - 1) {
3 return;
4 }
5 int counter = 0;
6 Node prev = head;
7 Node cur = head.next;
8 while (cur != null && counter < index) {
9 cur = cur.next;
10 prev = prev.next;
11 counter++;
12 }
13 prev.next = prev.next.next;
14 //更新length和last指针
15 length--;
16 while (prev.next != null) {
17 prev = prev.next;
18 }
19 this.last = prev;
20 }
4. 搜索：O(n)时间复杂度
1 /**
2 * 根据val搜索
3 * 返回第一个符合条件node的index
4 * 如果没有，返回-1
5 */
6 public int getByValue(int val) {
7 Node cur = head.next;
8 int index = 0;
9
10 while (cur != null) {
11 if (cur.val == val) {
12 return index;
13 }
14 cur = cur.next;
15 index++;
16 }
17 return -1;
18 }
19
20 /**
21 * 根据index搜索
22 */
23 public Node get(int index) {
24 if (index < 0 || index > length - 1) {
25 return null;
26 }
27 Node cur = head.next;
28 int counter = 0;
29 while (cur != null && counter < index) {
30 cur = cur.next;
31 counter++;
32 }
33 return cur;
34 }
完整代码：
1 /**
2 * Created by Mingxiao on 9/5/2016.
3 */
4 public class My_Single_LinkedList {
5
6 class Node {
7 public int val;
8 public Node next;
9
10 public Node(int val) {
11 this.val = val;
12 this.next = null;
13 }
14 }
15
16 public Node head; //头指针指向虚拟的node，真正的list是取head.next
17 public Node last; //尾指针指向最后一个元素
18 public int length; //list的长度，不是index。在insert的时候，判断insert的index
19
20 public My_Single_LinkedList() {
21 this.head = new Node(-1);
22 this.last = head;
23 this.length = 0;
24 }
25 // =============== INSERT==========================
26 public void addLast(int val) {
27 last.next = new Node(val);
28 last = last.next;
29 this.length++;
30 }
31
32 public void addFirst(int val) {
33 Node newNode = new Node(val);
34 newNode.next = head.next;
35 head.next = newNode;
36 this.length++;
37 }
38
39 /**
40 * insert before index
41 * @param val
42 * @param index
43 */
44 public void insertBefore(int val, int index) {
45 if (index <= 0) { //在0之前加，相当于addFirst
46 addFirst(val);
47 return;
48 }
49 if (index >= length) {//在超出length之前加，相当于addLast
50 addLast(val);
51 return;
52 }
53 // 普通情况，两个指针，一前一后
54 Node cur = head.next;
55 Node prev = head;
56 int counter = 0;
57 while (cur != null && counter < index) {
58 cur = cur.next;
59 prev = prev.next;
60 counter++;
61 }
62 Node newNode = new Node(val);
63 newNode.next = cur;
64 prev.next = newNode;
65 this.length++;
66 }
67
68 /**
69 * insert after index
70 * @param val
71 * @param index certain index you want to insert at
72 */
73 public void insertAfter(int val, int index) {
74 if (index < 0) {
75 addFirst(val);
76 return;
77 }
78 if (index >= length - 1) {
79 addLast(val);
80 return;
81 }
82 Node cur = head.next;
83 int counter = 0;
84 while (cur != null && counter < index) {
85 cur = cur.next;
86 counter++;
87 }
88 Node newNode = new Node(val);
89 newNode.next = cur.next;
90 cur.next = newNode;
91 this.length++;
92 }
93
94 //===================update=========================
95 public void updateAt(int val, int index) {
96 if (index < 0 || index > length - 1) {
97 return;
98 }
99 int counter = 0;
100 Node cur = head.next;
101 while (cur != null && counter < index) {
102 cur = cur.next;
103 counter++;
104 }
105 cur.val = val;
106 }
107 //=====================delete=======================
108 public void deleteAt(int index) {
109 if (index < 0 || index > length - 1) {
110 return;
111 }
112 int counter = 0;
113 Node prev = head;
114 Node cur = head.next;
115 while (cur != null && counter < index) {
116 cur = cur.next;
117 prev = prev.next;
118 counter++;
119 }
120 prev.next = prev.next.next;
121 //更新length和last指针
122 length--;
123 while (prev.next != null) {
124 prev = prev.next;
125 }
126 this.last = prev;
127 }
128 //===================search================================
129
130 /**
131 * 根据val搜索
132 * 返回第一个符合条件node的index
133 * 如果没有，返回-1
134 */
135 public int getByValue(int val) {
136 Node cur = head.next;
137 int index = 0;
138
139 while (cur != null) {
140 if (cur.val == val) {
141 return index;
142 }
143 cur = cur.next;
144 index++;
145 }
146 return -1;
147 }
148
149 /**
150 * 根据index搜索
151 */
152 public Node get(int index) {
153 if (index < 0 || index > length - 1) {
154 return null;
155 }
156 Node cur = head.next;
157 int counter = 0;
158 while (cur != null && counter < index) {
159 cur = cur.next;
160 counter++;
161 }
162 return cur;
163 }
164
165 public void print() {
166 if (head.next == null) {
167 System.out.println("null");
168 return;
169 }
170 Node cur = head.next;
171 while (cur.next != null) {
172 System.out.print(cur.val + "->");
173 cur = cur.next;
174 }
175 System.out.println(cur.val);
176 }
177
178
179 public static void main(String[] args) {
180 My_Single_LinkedList list = new My_Single_LinkedList();
181 list.addLast(1);
182 list.addLast(2);
183 list.addLast(0);
184 list.insertAfter(5,0);
185 list.updateAt(9, 1);
186 list.deleteAt(2);
187 System.out.println(list.get(2).val);
188 list.print();
189 }
190 }
时间： 2024-10-14 16:57:56