个人认为，算法是程序员的内功，不管你是能把 Java 或是 C # 玩出花来，也是需要注意提升一下内在修炼的。毕竟，只有深厚的内功才能把招式发挥到极致。以下算法，可能咋一看觉得很简单，自己也能实现，但是要知道能实现功能固然重要，但算法的效率更值得研究。纸上得来终觉浅，相信如果你能把以下算法都亲手实现一遍，必定会有收获，至少我个人是这样。
想要实现以下将介绍算法，首先需要自己实现一个 链表，下面粘贴上我利用前插法写的链表。
public class MyList {
private Node first;
public MyList(){
}
public class Node {
Node next;
int data;
public Node(Node next, int data) {
this.data = data;
this.next = next;
}
public Node(int data) {
this.data = data;
this.next = null;
}
public Node(){
}
}
public void add(int data) {
first = add(first, data);
}
private Node add(Node x, int data) {
if (x == null)
return new Node(data);
return new Node(x, data);
}
public Node getFirst() {
return first;
}
}
2.1 编写代码，移除未排序链表中的重复结点。如果不能使用缓冲区，又该怎么解决？
// 借用临时缓冲区的解法
public static void deleteSame(MyList list) {
MyList.Node current = list.getFirst();
MyList.Node pre = null;
Hashtable<Integer, Boolean> hashtable = new Hashtable<>();
while (current != null) {
if (hashtable.containsKey(current.data)) {
pre.next = current.next;
} else {
hashtable.put(current.data, true);
pre = current;
}
current = current.next;
}
}
// 不借用临时缓冲区
public static void deleteSameTwo(MyList list) {
MyList.Node current = list.getFirst();
MyList.Node runner;
while (current != null) {
runner = current;
while (runner.next != null) {
if (runner.next.data == current.data) {
runner.next = runner.next.next;
}
runner = runner.next;
}
current = current.next;
}
}
2.2 实现一个算法，找出单链表中倒数第 k 个结点．
// 只打印该元素，不返回该元素
private static int findOne(MyList.Node node, int k) {
if (node == null)
return 0;
int i = findOne(node.next, k) + 1;
if (i == k)
System.out.println(node.data);
return i;
}
// 基于以上方法 利用 IntWrapper返回该元素
private class IntWrapper {
public int value = 0;
}
private static MyList.Node findTwo(MyList.Node node, int k, IntWrapper i) {
if (node == null)
return null;
MyList.Node t = findTwo(node.next, k, i);
i.value = i.value + 1;
if (i.value == k) {
return node;
}
return t;
}
注意除了以上两种算法，还有一种方法，就是设置两个指针，一个是快指针，一个是慢指针，先让快指针向前移动 ｋ－１ 次，也就是移动到 第 ｋ 个元素，然后让 慢指针开始移动，这样的话当快指针指到末尾的时候，慢指针指向的刚好是 倒数第 ｋ 个元素。
2.3 实现一个算法，删除单向链表中间的某个结点，假定你只能访问该结点。
private static void delete(Node root) {
// 如果当前节点为空或者当前节点为尾节点的时候直接退出
if (root == null || root.next == null) {
return;
}
Node next = root.next;
root.data = next.data;
root.next = next.next;
}
2.4 编写代码，以给定值 x 为基准将链表分割成两部分，所有小于 x 的结点排在大于或等于 x 的节点之前。
public static Node divide(Node root, int x) {
MyList mins = new MyList();
MyList maxs = new MyList();
while (root != null) {
if (root.data < x) {
mins.add(root.data);
} else {
maxs.add(root.data);
}
root = root.next;
}
Node minRoot = mins.getFirst();
Node maxRoot = maxs.getFirst();
if (minRoot == null) {
return maxRoot;
}
Node temp = minRoot;
while (minRoot.next != null)
minRoot = minRoot.next;
minRoot.next = maxRoot;
return temp;
}
2.5 给定两个用链表表示的整数，每个节点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对两个整数求和，并用链表形式返回结果。
public static Node addLists(Node n1, Node n2, int carry) {
if (n1 == null && n2 == null && carry == 0) {
return null;
}
Node result = new MyList().new Node();
int value = carry;
if (n1 != null) {
value += n1.data;
}
if (n2 != null) {
value += n2.data;
}
result.data = value % 10;
Node more = addLists(n1 == null ? null : n1.next, n2 == null ? null : n2.next, value / 10);
result.next = more;
return result;
}
2.6 编写一个函数，检查链表是否为回文。
public static boolean isPalindrome(Node root) {
Node fast = root;
Node slow = root;
Stack<Integer> stack = new Stack<>();
while (fast != null && fast.next != null) {
stack.push(slow.data);
slow = slow.next;
fast = fast.next.next;
}
// 说明有奇数个元素，跳过中间元素
if (fast != null) {
slow = slow.next;
}
while (slow != null) {
int top = stack.pop().intValue();
if (top != slow.data)
return false;
slow = slow.next;
}
return true;
}
以上代码实现都是核心代码，需要完整代码的 点击此处
