数据结构之单链表的几个简单算法题

        单链表作为最基本的数据结构，在程序设计中有着非常重要的运用。最近自己闲下来，正在整理数据结构和算法的一些程序题，现将自己的代码贴出来与大家分享。如有不对之处，请大家指正。（好吧 ，这么简单的题目应该不会有错，都测试过了。况且说的好像很多人看我博客一样。好久没更，都长草了……就当做写给自己看的吧。:P）

package test;

import java.util.Hashtable;

class LinkNode{
int value;
LinkNode next;
public LinkNode(int d){
value = d;
}
public LinkNode(int d, LinkNode n){
value = d;
next = n;
}

/**
* 打印链表
*/
public static void printLinkedList(LinkNode head){
LinkNode p = head;
while( null != p ){
System.out.print("" + p.value + " ");
p = p.next;
}
System.out.println();
}
}

/**
* LinkNodeOperation
* 1.删除链表中重复的节点
* 2.找出单链表中倒数的第K个元素
* 3.实现单链表的反转
* 4.实现单链表逆向输出
* 5.寻找单链表中间节点
* 6.判断两条链表是否相交
*/
public class LinkNodeOperation {
public static void main(String[] args){
// 生成一条链表：
LinkNode n4 = new LinkNode(19,null);
LinkNode n3 = new LinkNode(20,n4);
LinkNode n2 = new LinkNode(30,n3);
LinkNode n1 = new LinkNode(40,n2);
LinkNode head1 = new LinkNode(50,n1);
// 生成一条值为0-20的链表,头结点为2：
LinkNode head = new LinkNode(2);
LinkNode cur = null;
for( int i=1; i<19; i++)
{
LinkNode temp = new LinkNode(i);
if( i==1 )
{
head.next = temp;
}
else{
cur.next = temp;
}
cur = temp;
}
cur.next = n4;
//打印原始链表：
System.out.print("原始链表：");
LinkNode.printLinkedList(head);

//打印原始链表：
System.out.print("待判断链表：");
LinkNode.printLinkedList(head1);
//判断两条链表是否相交：
System.out.println("是否相交："+ LinkNodeOperation.isIntersect(head, head1));

//寻找链表的中间节点：
System.out.print("链表的中间节点：");
LinkNodeOperation.findMiddleElem(head);

//从尾到头输出：
System.out.print("从尾到头输出单链表：");
LinkNodeOperation.printLinklistReversely(head);
System.out.println();

//打印倒数第K个节点：
LinkNodeOperation.findElem(head, 4);
System.out.println("----------------------------------------");
LinkNodeOperation.findElem2(head, 4);
System.out.println("----------------------------------------");

//打印去重后的链表：
System.out.print("去重后的链表：");
LinkNodeOperation.deleteDuplicate2(head);

//打印反转后的链表
LinkNode.printLinkedList(head);
System.out.print("反转后的链表：");
LinkNodeOperation.reverseElem(head);

}

/**
* 使用HashTable去重
*/
public static void deleteDuplicate(LinkNode head){
Hashtable<Integer, Integer> hashTable = new Hashtable<Integer, Integer>();
LinkNode tmp = head;
LinkNode pre = null;

while(tmp != null){
if(hashTable.containsKey(tmp.value)){
pre.next = tmp.next;
}else{
hashTable.put(tmp.value, 1);
pre = tmp;
}
tmp = tmp.next;
}
}
/**
* 使用常规方法：双重循环遍历
*/
public static void deleteDuplicate2(LinkNode head){
LinkNode p = head;
while(p!=null){
LinkNode q = p;
while(q.next!=null){
if(p.value == q.next.value){
q.next = q.next.next;
}
else{
q = q.next;
}
}
p = p.next;
}
}

/**
* 找出倒数第K个元素
* 方法1两次遍历
*/
public static void findElem(LinkNode head,int k){

int count = 1;
int index = 0;
LinkNode p = head;
while(p.next!= null){
count++;
p = p.next;
}
if( k<1 || k>count ){
return;
}
System.out.println("--------------------------------");
System.out.println("链表长度为："+ count);

while( head != null){
index++;
if(index == count-k+1){
break;
}
head = head.next;
}
System.out.println("倒数第" + k + "个节点为：" + head.value);
}

/**
* 找出倒数第K个元素
* 方法2 双指针 只需一次遍历
*/
public static void findElem2(LinkNode head, int k){
if(k<1){
return;
}
LinkNode p = head;
LinkNode q = head;
// 让P比Q先走K-1步
for(int i=1; i<=k-1; i++){
p = p.next;
}
while(p.next != null){
p = p.next;
q = q.next;
}
System.out.println("倒数第" + k +"个节点是：" + q.value );
}

/**
* 链表反转
*/
public static void reverseElem(LinkNode head){
LinkNode pre = head;
LinkNode cur = head.next;
LinkNode next= null;

while(null != cur){
next = cur.next;
cur.next = pre;
pre = cur;
cur = next;
}
head.next = null;
head = pre;
LinkNode.printLinkedList(head);
}

/**
* 从尾到头输出单链表
* 方法：递归
*/
public static void printLinklistReversely(LinkNode head){
if(head != null){
printLinklistReversely(head.next);
System.out.print(""+head.value+" ");
}
}

/**
* 寻找单链表的中间节点
*/
public static void findMiddleElem(LinkNode head){
LinkNode p = head;
LinkNode q = head;
while(p!=null && p.next!=null && p.next.next!=null ){
p = p.next.next;
q = q.next;
}
System.out.println(""+q.value);
}

/**
* 判断两条链表是否相交
*/
public static boolean isIntersect(LinkNode h1, LinkNode h2){
if (h1==null || h2==null) {
return false;
}
LinkNode tail1 = h1;
LinkNode tail2 = h2;

while(tail1.next!=null){
tail1 = tail1.next;
}
while(tail2.next!=null){
tail2 = tail2.next;
}

return tail1==tail2;
}
}

运行结果：