数据结构-java实现单链表

1.java实现单链表的定义

//定义一个类存储单链表的结点信息
class Node {
	Node next = null;
	int data;
	public Node(int data) {
		this.data = data ;
	}
}

2.java实现单链表的增加、删除、排序

import java.util.Hashtable;
public class MyLinkedList {
	Node head = null;//链表头地引用
	/**向链表中插入数据
	 * @param d:插入数据的内容
	 */
    public void addNode(int d) {
    	Node newNode = new Node(d);
    	if(head==null) {
    		head = newNode;
    		return;
    	}
		Node tmp = head;
		while(tmp.next != null) {
			tmp = tmp.next;
		}
		//add node to end
		tmp.next = newNode;
	}
    /**
     * @param index:删除第 index个结点
     * @return 成功返回true，否则返回false
     */
    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;
    }
    /**
     * @return 返回链表的长度
     */
    public int length() {
    	int length = 0;
    	Node tmp = head;
    	while(tmp != null) {
    		length ++;
    		tmp = tmp.next;
    	}
    	return length;
    }
    /**对链表进行排序
     * @return 返回排序后的头结点
     */
    public Node orderList() {
    	Node nextNode= null;
    	int temp = 0;
    	Node curNode = head;
    	while(curNode.next != null) {
    		nextNode = curNode.next;
    		while(nextNode != null) {
    			if(curNode.data > nextNode.data) {
    				temp = curNode.data;
    				curNode.data = nextNode.data;
    				nextNode.data = temp;
    			}
    			nextNode = nextNode.next;
    		}
    		curNode = curNode.next;
    	}
    	return head;
    }
    /**打印输出链表结点data
     * 
     */
    public void printList() {
    	Node temp = head;
    	while( temp != null) {
    		System.out.println(temp.data);
    		temp = temp.next;
    	}
    }
}

3.找出单链表中的倒数第k个元素

• 思路一：
  首先遍历一遍单链表，求出整个单链表的长度，然后将倒数第k个，转换成正数第n-k-1个，接着再遍历一次就可以得到结果。
  问题：遍历两次
• 思路二：
  从头到尾的方向遍历链表中的某个元素，如果遍历k个元素之后刚好到达链表尾，那么该元素就是要找的倒数第k个元素。
  问题：算法时间复杂度O(kn)，效率太低
• 思路三：
  我们可以设置两个引用（或者说指针，当然java中是没有指针的，但是这个引用和指针比较像），一个快指针，一个慢指针，快指针先前移k-1步，然后两个指针同时移动，这样子只要我们判断快指针是否为null（链表尾的next），如果是的话，慢指针指向的位置就是所要找的位置。

    /**倒数
     * @param k:倒数第k个元素
     */
    public Node findElem(Node head,int k) {
    	if(k<1) {
    		return null;
    	}
    	Node p1 = head;
    	Node p2 = head;
    	for(int i=0;i<k-1 && p1!=null;i++) {
    		p1 = p1.next;
    	}
    	if(p1 ==null) {
    		System.out.println("k不合法");
    		return null;
    	}
    	while(p1.next != null) {
    		p1=p1.next;
    		p2=p2.next;
    	}
    	return p2;
    }

4.找到单链表的中间结点

• 思路一：
  先计算单链表的长度，然后遍历length / 2的距离即可找到单链表的中间结点。
  问题：遍历两次单链表
• 思路二：
  双指针，快指针一次走两步，慢指针一次走一步，快指针到链表尾时，慢指针就到了单链表的中间（区分单链表的长度是奇数还是偶数，奇数时，慢指针刚好就是中部；偶数时，慢指针和它的下一个结点都是链表的中间结点）

    //找到单链表的中间结点
    public Node searchMid(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;
    }

5.从尾到头输出单链表

• 思路一：
  反转链表，然后输出

    //反转链表
    public void reverse(Node head) {
    	Node pReverseHead = head;
    	Node pNode = head;
    	Node pPre = null;
    	while(pNode!=null) {
    		Node pNext = pNode.next;
    		if(pNext == null) {
    			pReverseHead = pNode;//反转后的头结点应该到了单链表的尾部,所以next为null
    		}
    		pNode.next = pPre;
    		pPre = pNode;
    		pNode = pNext;
    	}
    	this.head = pReverseHead;
    }

• 思路二：
  栈结构，先进后出，递归本质上就是一个栈结构。方法：每访问一个结点，先递归输出后面的结点，再输出本身。

    //递归
    public void printListReverse(Node pListHead) {
    	if(pListHead != null) {
    		printListReverse(pListHead.next);
    		System.out.println(pListHead.data);
    	}
    }

6.不知道头指针的情况下删除指定结点

    //删除指定结点
    public boolean deleteNode(Node n) {
    	//如果是链表尾结点无法删除,因为无法使其的前驱结点的next置为null
    	if(n == null || n.next == null) {
    		return false;
    	}
    	//不是尾结点
    	//先交换该结点和后继的值
    	int temp =n.data;
    	n.data = n.next.data;
    	n.next.data = temp;
    	//之后将后继结点删除
    	n.next = n.next.next;
    	return true;
    	
    }

7.删除重复数据

 /**删除重复数据
     * 
     */
	//利用哈希表,时间复杂度较低,但是需要额外的空间
    public void deleteDuplecate1(Node head) {
    	Hashtable<Integer,Integer> table = new Hashtable<Integer,Integer>();
    	Node temp = head;
    	Node pre = null;
    	while(temp != null) {
    		if(table.containsKey(temp.data)) {
    			pre.next = temp.next;
    		}else {
    			table.put(temp.data, 1);//需要额外空间
    			pre = temp;
    		}
    		temp = temp.next;
    	}
    }
    //时间复杂度较高,但是不需要额外的空间
    public void deleteDuplecate2(Node head) {
    	Node p = head;
    	while(p != null) {
    		Node q = p;
    		while(q.next != null) {
    			if(p.data == q.next.data) {
    				q.next = q.next.next;
    			}else {
    				q = q.next;
    			}
    			p = p.next;
    		}
    	}
    }