Java中单链表的部分操作总结

public class Node {
Node next = null;
int data;

public Node(int data) {
this.data = data;
}

public String toString() {
return this.data + "";
}
}

import java.util.Hashtable;

public class MyLinkedList {
static Node head = null;

public static void main(String[] args) {
MyLinkedList list = new MyLinkedList();
list.add(5);
list.add(3);
list.add(2);
list.add(3);
System.out.print("length:" + list.length() + "\n");
list.print();
/*
* 删除指定点
*/
list.deleteNode(4);
System.out.print("删除指定点后  length:" + list.length() + "\n");
list.print();
/*
* 指定点处插入数据
*/
list.addNode(7, 8);
System.out.print("指定点处插入数据后 length:" + list.length() + "\n");
list.print();
/*
* 排序
*/
list.orderList();
list.print();
/*
* 刪除重复数据
*/
list.deleteDuplecate2(head);
list.print();
/*
* 找出单链表中倒数第K个元素
*/
System.out.print(list.findElemFromEnd(head, 3));
/*
* 单链表的反转
*/
list.ReverseIteratively(head);
list.print();
/*
* 从尾到头输出单链表
*/
list.printListRevaesely(head);
list.print();
/*
* 寻找单链表的中间结点
*/
System.out.println(list.searchNode(head));

}

/*
* 刪除链表中重复数据：方法一 时间复杂度低，但是需要额外的空间
*/
public void deleteDuplecate1(Node head) {
Hashtable<Integer, Integer> table = new Hashtable<Integer, Integer>();
Node tmp = head;
Node pre = null;
while (tmp != null) {
if (table.containsKey(tmp.data)) {
pre.next = tmp.next;

} else {
table.put(tmp.data, 1);
pre = tmp;
}
tmp = tmp.next;
}
}

/*
* 刪除链表中重复数据：方法二 不需要额外的空间， 时间复杂度高
*/
public void deleteDuplecate2(Node head) {
Node p = head;
while (p != null) {
Node q = p;
while (q.next != null) {
if (q.next.data == p.data) {
q.next = q.next.next;
} else {
q = q.next;
}
}
p = p.next;
}
}

/*
* 找出单链表中的倒数第K个元素
*/
public Node findElemFromEnd(Node head, int k) {
if (k < 1 || k > length()) {
return null;
}
Node p1 = head;
Node p2 = head;
for (int i = 0; i < k - 1; i++) {
p1 = p1.next;
}
while (p1 != null) {
p1 = p1.next;
p2 = p2.next;
}

return p2;

}

/*
* 找出单链表的中间结点
*/
public Node searchNode(Node head) {
Node p = this.head;
Node q = this.head;
while (p != null && p.next != null && p.next.next != null) {
p = p.next.next;
q = q.next;
}
return q;

}

/*
* 向链表尾部添加数据
*/
public void add(int data) {
Node newNode = new Node(data);
if (head == null) {
head = newNode;
return;
}
Node tmp = head;
while (tmp.next != null) {
tmp = tmp.next;
}
tmp.next = newNode;
}

/*
* 在第index个结点插入数据
*/
public Boolean addNode(int index, int data) {
Node newNode = new Node(data);
if (index < 1) {
return false;
}
if (index == 1) {
newNode.next = head;
head = newNode;
return true;
}
if (index > length()) {
add(data);
return true;
}
int i = 2;
Node preNode = head;
Node curNode = preNode.next;
while (curNode != null) {
if (i == index) {
preNode.next = newNode;
newNode.next = curNode;
return true;
}
preNode = curNode;
curNode = curNode.next;
i++;
}
return true;

}

/*
* 单链表的反转
*/
public void ReverseIteratively(Node head) {
Node pReversedHead = head;
Node pNode = head;
Node pPrev = null;
while (pNode != null) {
Node pNext = pNode.next;
if (pNext == null) {
pReversedHead = pNode;
}
pNode.next = pPrev;
pPrev = pNode;
pNode = pNext;
}
this.head = pReversedHead;
}

/*
* 从尾到头输出单链表：采用递归实现，单链表实际上并没有反转
*/
public void printListRevaesely(Node pListHead) {
if (pListHead != null) {
printListRevaesely(pListHead.next);
System.out.println(pListHead.data);
}

}

/*
* 链表中的排序
*/
public void orderList() {
Node nextNode = null;
Node curNode = head;
int tmp = 0;
while (curNode.next != null) {
nextNode = curNode.next;
while (nextNode != null) {
if (curNode.data > nextNode.data) {
tmp = curNode.data;
curNode.data = nextNode.data;
nextNode.data = tmp;
}
nextNode = nextNode.next;
}
curNode = curNode.next;
}

}

/*
* 删除第index个结点
*/
public Boolean deleteNode(int index) {

if (index < 1 || index > length()) {
return false;
}

if (index == 1) {
head = head.next;
return true;
}
int i = 2;
Node preNode = head;
Node curNode = preNode.next;
while (curNode != null) {
if (i == index) {
preNode.next = curNode.next;
return true;
}
preNode = curNode;
curNode = curNode.next;
i++;
}
return true;
}

/*
* 返回结点的长度
*/
public int length() {
int length = 0;
Node tmp = head;
while (tmp != null) {
length++;
tmp = tmp.next;

}

return length;

}

/*
* 打印链表的所有节点
*/
public void print() {
Node tmp = head;
while (tmp != null) {
System.out.print(tmp.data + "——>");
tmp = tmp.next;
}
System.out.print("尾部" + "\n");

}
}