数据结构----------单链表
数据结构（一） 单链表的实现
一. 单链表的简单介绍
单链表在整个数据结构中可以说是相对比较简单的，但是它的作用却不可忽视，许多相对复杂的数据结构都是基于单链表实现的。在这里我们简单介绍一下单链表。
单链表有节点构成，每个节点封装了数据和下一个节点的地址，最后一个节点指向null。
二. 单链表的java实现
（一）API
该实现单链表可以适合用于存储实现了Comparable接口的任意对象，因此可以对不同节点进行比较，链表内部维护了一个first 和last指针，分别指向链表的头结点和尾节点，size变量存储的是链表的长度。
内部为了了一个Node类，它的实例用于表示节点对象，存储相应的数据和下一个节点的地址。
该实现可以用来添加节点、删除节点、遍历节点、反转链表等，具体介绍参见具体实现。
（二）具体实现
- 添加节点
1. 插入节点（默认从尾部插入）
/** * 向链表中添加节点（从链表尾部添加节点） * 如果链表为空，则链表的第一个节点的最后一个节点都指向新添加的节点 * 如果链表不为空，将最后一个节点的next指向新产生的节点，并将新节点设为最后一个节点 * 节点数加1 * @param data */ public void add(T data) { Node newNode = new Node(data); if(first == null) {//链表为空 first = newNode; last = first; }else {//链表不为空 last.next = newNode; last = newNode; } size++;//节点数加1 }
2. 从链表头部插入节点
/** * 从链表头部添加元素 * @param data */ public void addAtHeader(T data) { Node newNode = new Node(data); if(first == null) { first = newNode; last = first; }else { newNode.next = first; first = newNode; } size++; }
- 删除节点
1. 删除头部节点/** * 删除头结点
* @return */ public T deleteFirst() {
if(first == null)
return null;
T data = first.data; first = first.next; size--; return data; }
2. 删除指定位置节点
/** * 删除指定位置的节点 * @param index * @return */ public T deleteNode(int index) { Node preCurrent = null; Node current = first; if(index == 0) { return deleteFirst(); } int i = 0; while(i < index) { preCurrent = current; current = current.next; i++; } preCurrent.next = current.next; size--; return current.data; }
- 遍历节点
1. 遍历节点
/** * 遍历打印所有节点 */ public void print(Node node) { Node current = node; int i = 0; while(current != null) { System.out.println("This is the "+i+"th Node："+current.data); current = current.next; i++; } }
2. Iterable实现节点遍历
/** * 遍历方法2： 链表实现Iterable接口，返回一个Iterator对象 * */ @Override public Iterator<T> iterator() { return new Iterator<T>() { Node current = first;//内部维护一个当前节点对象 @Override public boolean hasNext() { return current != null; } @Override public T next() { Node returnNode = current; current = current.next;//小心 return returnNode.data; } }; }
- 反向遍历节点
/** * * 从为到头遍历链表:递归实现 * 也可采用栈，正向遍历压栈，循环完毕，弹栈输出 */ public void printFromLastToFirst() { reversePrint(first); } public void reversePrint(Node n) { if(n == null) { return; } reversePrint(n.next); System.out.println("Node: "+n.data); }
- 链表反转
/** * 链表反转：遍历实现 * 返回反转后链表的头结点 */ public Node reverseNode(Node head) { Node pre = null; while(head != null) { Node temp = head.next;//保留当前头结点的下一个节点 head.next = pre; pre = head; head = temp; } return pre; }
/** * 链表反转：遍历实现 * 思想：翻转head->为首的链表， 然后head变为尾部节点 */ public Node reverseNode(Node head) { if(head == null || head.next == null) { return head; } Node pre = reverseNode(head.next); head.next.next = head; head.next = null; return prev; }
- 返回链表第k个元素
1. 实现1
/** * 返回链表倒数第k个节点(实现1) * 1. 返回链表总长度，计算倒数第k个节点的索引 * 2. 遍历并返回倒数第k个节点 * @param index * @return */ public T findLastNode1(int index) { Node returnNode = first; int k = size()-index;//k为要返回节点的索引 if(k < 0) { throw new NullPointerException("链表长度越界 "); } for(int i = 0; i < k; i++) { returnNode = returnNode.next; } return returnNode.data; }
2. 实现2
/** * 返回链表倒数第k个元素（实现2） * 倒数第k个元素和最后一个元素相差k-1，所以可以选择两个指针 * 1. 将第一个指针从头结点移动k-1次，使头结点和这个节点相差k-1 * 2. 同时移动两个节点，当该节点是最后一个节点时，头结点为倒数第k个节点 * @param index * @return */ public T findLastNode2(int index) { Node firstNode = first; Node lastNode = first; //lastNode向后移动k-1次 for(int i = 0; i < index - 1; i++) { if(lastNode == null) { throw new NullPointerException("链表长度越界"); } lastNode = lastNode.next; } //同时移动，指针lastNode为最后一个节点 while(lastNode.next != null) { firstNode = firstNode.next; lastNode = lastNode.next; } return firstNode.data; }
- 合并两个有序链表
/** * 合并两个有序链表 * @param head2 要合并的链表的头结点 * @return 合并后的有序链表的头结点 */ public Node merge(Node head2) { Node head1 = this.first;//当前链表的头结点 if(head1 == null && head1 == null) return null; if(head1 == null) return head2; if(head2 == null) return head1; Node head = null;//新生成链表的头结点 Node current = null;//新生成链表的当前节点 while(head1 != null || head2 != null) {//至少一个链表没有循环完 //1.为新生成的链表添加第一个节点 if(head == null) { if(head1.data.compareTo(head2.data) < 0) { head = head1; current = head; head1 = head1.next; }else { head = head2; current = head; head2 = head2.next; } } //2.为生成的节点添加后续节点 //如果head1为空，直接将当前节点指向head2，返回head即可 if(head1 == null) { current.next = head2; return head; } //如果head2为空，直接将当前节点指向head1，返回即可 if(head2 == null) { current.next = head1; return head; } //如果两个节点都不为空，进行比较，比较后继续循环 if(head1.data.compareTo(head2.data) < 0) { current.next = head1; current = head1; head1 = head1.next; }else { current.next = head2; current = head2; head2 = head2.next; } } return head; }
- 判断链表是否有环
/** * 判断单链表是否有环 * 使用两个指针，first指针每次移动一步，second指针每次移动2步 * @return */ public boolean hasCycle() { Node first = this.first; Node second = this.first; while(second != null) { first = first.next;//每次移动一次 second = second.next.next;//每次移动两次 if(first == second) { return true; } } return false; }
