数据结构学习java（一点五）链式顺序表（链表）
java中没有将指针暴露给用户（以前做过看过一篇文章写有java中是有指针的，只是被藏起来了），所以得使用引用的方式。
何为引用请看下面这篇文章（写的很不错，当然肯定比我写的好）：
https://www.cnblogs.com/huajiezh/p/5835618.html
链表中内部类和嵌套类的区别：
https://blog.csdn.net/WelcomeSpring/article/details/79430546
以下代码采用内部类。
1 /** 2 * 内部类 3 * @param <E> 泛型 4 */ 5 private class Node<E>{ 6 E data; 7 Node<E> next; 8 Node<E> pre; 9 public Node(E data){ 10 this.data=data; 11 } 12 13 public Node(E data, Node next, Node pre) { 14 this.data = data; 15 this.next = next; 16 this.pre = pre; 17 } 18 public Node(){ 19 next=null; 20 pre=null; 21 data=null; 22 } 23 public E getData() { 24 return data; 25 } 26 27 public void setData(E data) { 28 this.data = data; 29 } 30 31 public Node getNext() { 32 return next; 33 } 34 35 public void setNext(Node next) { 36 this.next = next; 37 } 38 39 public Node getPre() { 40 return pre; 41 } 42 43 public void setPre(Node pre) { 44 this.pre = pre; 45 } 46 }
E data：存储对象的区域 Node<E> next:引用链表的下一个对象 Node<E> pre;引用链表的上一个对象 所构成了一个双链表
源代码：
1 /** 2 * @author 李正阳 3 * @param <E> 泛型 4 */ 5 public class MyLinkedList<E> implements List<E> { 6 7 private Node<E> head=new Node<>(); 8 private int size=0; 9 10 /** 11 * 在链表的最后插入元素 12 * @param data 插入的元素 13 * @return true 插入成功 14 */ 15 @Override 16 public boolean add(E data) { 17 Node<E> pNode= head; 18 while (pNode.getNext()!=null){ 19 pNode=pNode.next; 20 } 21 Node<E> temp=new Node(data); 22 temp.setPre(pNode); 23 pNode.setNext(temp); 24 size++; 25 return true; 26 } 27 28 /** 29 *在number位置添加一个元素 30 * @param number 在链表中的位置（不是从0开始） 31 * @return true 添加成功 32 */ 33 @Override 34 public boolean add(int number,E data){ 35 Node<E> pNode=head; 36 Node<E> temp=new Node<>(data); 37 for (int i=0;i<number;i++){ 38 pNode= pNode.getNext(); 39 } 40 pNode.getPre().setNext(temp); 41 temp.setPre(pNode.getPre()); 42 temp.setNext(pNode.getNext()); 43 pNode.getNext().setPre(temp); 44 return true; 45 } 46 /** 47 * 判空函数 48 * @return true 链表为空 false 链表不为空 49 */ 50 @Override 51 public boolean isEmpty() { 52 if(head.getNext()==null){ 53 return true; 54 }else { 55 return false; 56 } 57 } 58 59 /** 60 * 删除链表中number位置的元素 61 * @param number 元素在链表中的位置 62 * @return 删除的那个元素 63 */ 64 @Override 65 public E remove(int number) { 66 E temp; 67 Node<E> pNode,preNode; 68 pNode=head; 69 for(int i=0;i<number;i++){ 70 pNode=pNode.next; 71 } 72 temp=(E) pNode.getData(); 73 preNode=pNode.getPre(); 74 preNode.setNext(pNode.getNext()); 75 pNode.getNext().setPre(preNode); 76 pNode.setNext(null); 77 pNode.setPre(null); 78 pNode=null; 79 return temp; 80 } 81 82 /** 83 * 尾删法 84 * @return 删除的那个元素 85 */ 86 @Override 87 public E remove() { 88 E temp; 89 Node<E> pNode,preNode; 90 pNode=head; 91 while (pNode.getNext()!=null){ 92 pNode=pNode.next; 93 } 94 temp=(E) pNode.getData(); 95 preNode=pNode.getPre(); 96 preNode.setNext(null); 97 pNode.setNext(null); 98 pNode.setPre(null); 99 pNode=null; 100 return temp; 101 } 102 103 /** 104 * 将第i位置的元素替换 105 * @param i 元素在链表中的位置 106 * @param data 替换的元素 107 */ 108 @Override 109 public void set(int i, E data) { 110 Node<E> pNode=head; 111 for (int j=0;j<i;j++){ 112 pNode=pNode.getNext(); 113 } 114 pNode.setData(data); 115 } 116 117 /** 118 * 获得链表在i位置的元素 119 * @param i 元素在i位置的元素 120 * @return i位置的元素 121 */ 122 @Override 123 public E get(int i) { 124 E temp; 125 Node<E> pNode=head; 126 for (int j=0;j<i;j++){ 127 pNode=pNode.getNext(); 128 } 129 temp=(E) pNode.getData(); 130 return temp; 131 } 132 133 /** 134 * 检查这条链表现有的是否为回文 135 * @return true 为回文 false 不为回文 136 */ 137 @Override 138 public boolean isPalindrome() { 139 Node<E> pNode,nNode; 140 pNode=head.getNext(); 141 nNode=head; 142 while (nNode.getNext()!=null){ 143 nNode=nNode.getNext(); 144 } 145 StringBuilder posSequence=new StringBuilder(); 146 StringBuilder revOrder=new StringBuilder(); 147 while(pNode.getNext()!=null) { 148 posSequence.append(pNode.getData()); 149 pNode=pNode.getNext(); 150 } 151 posSequence.append(pNode.getData()); 152 while (nNode.getPre()!=null){ 153 revOrder.append(nNode.getData()); 154 nNode=nNode.getPre(); 155 } 156 String posequence=posSequence.toString(); 157 String revoredr=revOrder.toString(); 158 if(posequence.equals(revoredr)) { 159 return true; 160 }else { 161 return false; 162 } 163 } 164 165 /** 166 * 倒置链表 167 */ 168 @Override 169 public void reverseList(){ 170 Node<E> node,nNode; 171 node=head.getNext(); 172 node.setPre(node.getNext()); 173 node=node.getNext(); 174 nNode=node.getNext(); 175 head.getNext().setNext(null); 176 while (nNode!=null) { 177 node.setNext(node.getPre()); 178 node.setPre(nNode); 179 node=node.getPre(); 180 nNode=node.getNext(); 181 } 182 node.setNext(node.getPre()); 183 node.setPre(head); 184 head.setNext(node); 185 } 186 /** 187 * 头插法 188 * @param data 插入的元素 189 * @return true 添加成功 false 添加失败 190 */ 191 @Override 192 public boolean addFirst(E data){ 193 Node<E> node=new Node(data); 194 Node<E> preNode=head.getNext(); 195 head.setNext(node); 196 preNode.setPre(node); 197 node.setNext(preNode); 198 node.setPre(head); 199 return true; 200 } 201 202 /** 203 * 遍历并输出链表中的元素 204 */ 205 @Override 206 public void traver() { 207 if(isEmpty()){ 208 System.out.println("链表为空"); 209 }else { 210 Node<E> pNode = head.getNext(); 211 while (pNode != null) { 212 System.out.print(pNode.getData() + " "); 213 pNode = pNode.getNext(); 214 } 215 } 216 } 217 218 /** 219 * 内部类 220 * @param <E> 泛型 221 */ 222 private class Node<E>{ 223 E data; 224 Node<E> next; 225 Node<E> pre; 226 public Node(E data){ 227 this.data=data; 228 } 229 230 public Node(E data, Node next, Node pre) { 231 this.data = data; 232 this.next = next; 233 this.pre = pre; 234 } 235 public Node(){ 236 next=null; 237 pre=null; 238 data=null; 239 } 240 public E getData() { 241 return data; 242 } 243 244 public void setData(E data) { 245 this.data = data; 246 } 247 248 public Node getNext() { 249 return next; 250 } 251 252 public void setNext(Node next) { 253 this.next = next; 254 } 255 256 public Node getPre() { 257 return pre; 258 } 259 260 public void setPre(Node pre) { 261 this.pre = pre; 262 } 263 } 264 265 }
检查链表所存储是否为回文：
1 /** 2 * 检查这条链表现有的是否为回文 3 * @return true 为回文 false 不为回文 4 */ 5 @Override 6 public boolean isPalindrome() { 7 Node<E> pNode,nNode; 8 pNode=head.getNext(); 9 nNode=head; 10 while (nNode.getNext()!=null){ 11 nNode=nNode.getNext(); 12 } 13 StringBuilder posSequence=new StringBuilder(); 14 StringBuilder revOrder=new StringBuilder(); 15 while(pNode.getNext()!=null) { 16 posSequence.append(pNode.getData()); 17 pNode=pNode.getNext(); 18 } 19 posSequence.append(pNode.getData()); 20 while (nNode.getPre()!=null){ 21 revOrder.append(nNode.getData()); 22 nNode=nNode.getPre(); 23 } 24 String posequence=posSequence.toString(); 25 String revoredr=revOrder.toString(); 26 if(posequence.equals(revoredr)) { 27 return true; 28 }else { 29 return false; 30 } 31 }
* 算法设计：比较粗暴，直接从链表头到尾将值组成一个String
* 从链表尾到头将值组成一个String
* 然后比较这两个字符串是否相等
链表倒置：
1 /** 2 * 倒置链表 3 * 算法设计 4 */ 5 @Override 6 public void reverseList(){ 7 Node<E> node,nNode; 8 node=head.getNext(); 9 node.setPre(node.getNext()); 10 node=node.getNext(); 11 nNode=node.getNext(); 12 head.getNext().setNext(null); 13 while (nNode!=null) { 14 node.setNext(node.getPre()); 15 node.setPre(nNode); 16 node=node.getPre(); 17 nNode=node.getNext(); 18 } 19 node.setNext(node.getPre()); 20 node.setPre(head); 21 head.setNext(node); 22 }
* 算法设计：倒置链表需要修改三处地方，
* 头结点变成尾节点:将pre赋值尾next的引用,next赋值为null
* 尾节点变成头结点：将next赋值为pre，pre赋值为null
* 中间节点将next设置为pre，next设置为pre
