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

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

运行结果：