数据结构---单链表（1）

1. 单链表

1.1 java实现

先定义一个Node类用来存储节点的值域和指针域 

public class LNode {
	protected int data;
	protected LNode next;

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

定义一个链表主类，并且定义各种对链表操作的方法 

//带头结点的单链表
public class Linklist {

	private LNode head;// 定义一个头结点

	Linklist() {
		head = new LNode(0);
		this.head.next = null;
	}

	// 插入节点--默认头插法
	public void add(int data) {
		LNode node = new LNode(data);
		LNode head = this.head.next;
		node.next = head;
		this.head.next = node;
	}

	// 指定位置之前插入节点
	// pos--插入的位置 value--插入的值
	public boolean add(int pos, int value) {
		LNode p = this.head;
		int j = 0;
		while (p != null && j < pos - 1) {
			p = p.next;
			j++;
		}
		// 插入位置小于1或者大于表长+1
		if (p == null || j > pos - 1)
			return false;

		LNode node = new LNode(value);
		node.next = p.next;
		p.next = node;
		
		return true;

	}

	// 删除节点
	public LNode delete(int value) {
		LNode current = this.head.next;
		LNode previous = this.head; // 记住上一个节点
		while (current.data != value) {
			if (current.next == null) {
				return null;
			}
			previous = current;
			current = current.next;
		}
		previous.next = current.next;
		return current;
	}

	// 显示出所有的节点信息
	public void displayAllNodes() {
		LNode current = this.head.next;
		while (current != null) {
			System.out.println(current.data + "  ");
			current = current.next;
		}
		System.out.println();
	}

}

2.从尾到头打印链表(剑指offer-5)

题目：输入一个链表的头结点，从尾到头反过来打印出每个结点的值。

解析：这就是典型的“后进先出”，可以用栈实现这种顺序。每经过一个结点的时候，把该结点放到一个栈中。当遍历完整个链表后，再从栈顶开始逐个输出结点的值，此时输出的结点的顺序已经反转过来了。

栈实现：

	//从尾到头打印链表
	public void PrintListReverse(Linklist L) {
		
		Stack<Integer> s = new Stack<Integer>();
		LNode Lhend = L.head.next;
		
		while (Lhend != null) {
			s.add(Lhend.data);
			Lhend = Lhend.next;
		}
		
		while(!s.isEmpty()){
			System.out.print(s.peek()+" ");
			s.pop();
		}
	}

递归实现：

	public void PrintListReverse(LNode L) {
		if(L!=null){
			if(L.next!=null){
				PrintListReverse1(L.next);
			}
			System.out.print(L.data+" ");
		}
	}

3. O(1)时间内删除指定链表结点(剑指offer-13)
题目：给定单链表头指针和一个结点指针，定义一个函数在O(1)时间内删除该结点。

解析：对于上图实例链表（a）删除指针p有两种方式

思路1：(b)找到前一个指针pre，赋值pre->next = p->next，删掉p

思路2：(c)目的是删除p，但是不删p，直接用p->next的值赋值给p，把p->next删除掉（好处：不用遍历找到p的前一个指针pre,O（1）时间内搞定）

于是，定位到思路2，但是思路2有两个特例：
删除的是尾指针，需要遍历找到前一个指针
整个链表就一个结点（属于删尾指针，但没法找到前面的指针，需要单独处理）

java代码实现：

	// 删除给定指针的节点
	public void deleteNode(LNode head, LNode toBeDelete) {

		if (head == null || toBeDelete == null) {
			return;
		}

		if (toBeDelete.next != null) { // 不是尾结点
			LNode node = toBeDelete.next;
			toBeDelete.data = node.data;
			toBeDelete.next = node.next;
			node = null;
		} else if (head == toBeDelete) {// 只有一个结点，删除头结点
			toBeDelete = null;
			head = null;
			return;
		} else {// 多个结点，删除尾结点
			LNode node = head;
			while (node.next != toBeDelete) {
				node = node.next;
			}
			node.next = null;
			toBeDelete = null;
		}

	}

4. 链表中倒数第K个结点(剑指offer-15)

题目：输入一个链表，输出该链表中倒数第K个结点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾结点是倒数第1个结点。例如一个链表有6个结点，从头结点开始它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个结点是值为4的结点。

解析：设定两个指针p1和p2，两个指针刚开始都指向链表的第一个结点，然后让p1指针先走(k-1)步，然后再让两个指针一起往后走，当p1指针指向链表最后一个结点的时候，p2指针刚好指向链表中的倒数第k个结点。
在写代码的时候需要考虑鲁棒性，最好采用防御性编程，就是考虑在哪些地方会出错，然后提前加上错误判断，这样避免因此错误输入而导致程序崩溃。

java代码：

	// 查找链表中倒数第K个结点
	public LNode findKthToTail(LNode head, int k) {
		if (head.next == null || k == 0)
			return null;

		LNode pNode = head;
		LNode pKthNode = head;

		while (k - 1 > 0) {
			if (pNode.next != null) {
				pNode = pNode.next;// 让pNode先走k-1步
				--k;
			} else {
				return null;
			}
		}

		while (pNode.next != null) {
			pNode = pNode.next;
			pKthNode = pKthNode.next;
		}

		return pKthNode;
	}

相关题目
1.求链表的中间结点。如果链表中结点总数为奇数，返回中间结点；如果结点总数是偶数，返回中间两个结点的任意一个。为了解决这个问题，我们也可以定义两个指针，同时从链表的头结点出发，一个指针一次走一步，另一个指针一次走两步。当走得快的指针走到链表的末尾时，走得慢的指针正好在链表的中间。

2.判断一个单向链表是否形成了环状结构。和前面的问题一样，定义两个指针，同时从链表的头结点出发，一个指针一次走一步，另外一个指针一次走两步。如果走得快的指针追上了走得慢的指针，那么链表就是环状结构；如果走得快的指针走到了链表的末尾（m_pNext指向NULL）都没有追上走得慢的指针，那么链表就不是环状结构。

后续：数据结构---单链表（2）

参考来源：

面试题15：链表中倒数第K个结点

轻松搞定面试中的链表题目