链表（上）

链表作为最进本的数据结构，在程序设计中有着非常重要的作用，其存储特点如下：可以用任意一组存储单元来存储单链表中的数据元素（存储单元可以是不连续的），而且，除了存储每个数据元素的值以外，还必须存储指示其直接后继元素的信息，这两部分信息组成的数据元素的存储映像称为结点。N个结点链在一块被称为链表，当结点只包含其后继结点的信息的链表就被称为单链表。
单链表有带头结点和不带头结点之分：
不带头结点

带头结点

eg1：基本操作
先定义如下数据类来存储结点信息

public class Node {
    Node next=null;
    int data;
    public Node(){};
    public Node(int data){
        this.data=data;
    }

}

package linkedlist;

public class MyLinkedList {
    Node head=null;//链表头，不带头结点

    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;
        }
        tmp.next=newNode;
    }

    public Boolean deleteNode(int index){//删除第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;
    }

    public int length(){//返回长度
        int length=0;
        Node tmp=head;
        while(tmp!=null){//tmp.next!=null不一样

            length++;
            tmp=tmp.next;
        }
        return length;
    }

    public Node orderList(){//对链表进行排序，返回排序后的头结点
        Node nextNode=null; //选择排序
        int temp=0;
        Node curNode=head;
        while(curNode!=null){
            nextNode=curNode.next;
            while(nextNode!=null){//第一个和剩下的进行比较获得min
                if(curNode.data>nextNode.data){
                    temp=curNode.data;
                    curNode.data=nextNode.data;
                    nextNode.data=temp;
                }
                nextNode=nextNode.next;
            }
            curNode=curNode.next;
        }
        return head;
    }

    public void printList(){
        Node tmp=head;
        while(tmp!=null){
            System.out.println(tmp.data);
            tmp=tmp.next;
        }
    }

    public static void main(String [] args){
        MyLinkedList list=new MyLinkedList();
        list.addNode(3);
        list.addNode(1);
        list.addNode(5);
        list.addNode(3);
        list.printList();
        System.out.println(list.length());

        list.deleteNode(1);//数的是个数，删除第一个，不是索引0
        System.out.println("listLen="+list.length());
        System.out.print("before order:");
        list.printList();
        list.orderList();
        System.out.print("after order:");
        list.printList();

    }

}

eg2：从链表中删除重复数据

package linkedlist;
import java.util.*;
/*
 * 从链表中删除重复数据
 */

public class DeleteDuplecate {
    /*
     * 遍历链表，把遍历到的值存储到一个Hashtable中，在遍历过程中，若当前访问的值
     * 在Hashtable中已经存在，说明这个数据是重复的，可以删除
     * 时间复杂度低，但是在遍历过程中需要额外的存储空间来保存已遍历过的值
     */
    public static void deleteDuplecate(Node head){
        Hashtable<Integer,Integer> table=new Hashtable<Integer,Integer>();
        Node tmp=head;
        Node pre=null;
        while(tmp!=null){
            if(table.containsKey(tmp.data)){
                pre.next=tmp.next;
            }
            else{
                table.put(tmp.data, 1);
                pre=tmp;
            }
            tmp=tmp.next;
        }
    }

    /*
     * 双重循环遍历，外循环正常遍历链表
     * 假设外循环当前遍历的结点为cur，内循环从cur开始遍历，若碰到与cur所指向结点值相同
     * 则删除这个重复结点
     * 不需要额外的存储空间，但时间复杂度比上面高
     */

    public static void deleteduplecate(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;
        }
    }

    public static void print(Node head){
        while(head!=null){
            System.out.print(head.data+" ");
            head=head.next;
        }
        System.out.println();
    }

    public static void main(String[] args){
        int[] num={2,4,3,3,5};
        Node head=new Node();
        Node pre=head;
        for(int i=0;i<num.length;i++){
            Node node=new Node(num[i]);
            pre.next =node;
            pre=node;
        }
        print(head.next);
        deleteduplecate(head);
//      deleteDuplecate(head);
        print(head.next);
    }

}

eg3：找出单链表中倒数第k个元素

package linkedlist;
/*
 * 找出单链表中倒数第k个元素
 * 方法一：先遍历一边单链表，求出长度n，然后将倒数第k个转为正数n-k个
 * 再遍历一次即可得到，问题，需要对链表进行两次遍历
 * 方法二：
 * 设置两个指针，其中一个比另一个先前移k-1步，然后两个指针同时前移
 * 先行的指针值为null时另一个指针所指的位置就是要找的位置
 */
public class FindElem {

    public static 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先前移k-1
            p1=p1.next;
        }
        if(p1==null){
            System.out.println("k is illegal");
            return null;
        }
        while(p1.next!=null){//p1,p2同前移
            p1=p1.next;
            p2=p2.next;
        }
        return p2;
    }

    public static void main(String [] args){//简单测试，输出为1
        int[] num={2,4,1,3,5,6};
        Node head=new Node();
        Node pre=head;
        for(int i=0;i<num.length;i++){
            Node node=new Node(num[i]);
            pre.next =node;
            pre=node;
        }
        Node result=findElem(head,4);
        System.out.println(result.data);
    }

}

eg4：从尾到头输出单链表

package linkedlist;
/*
 * 方法一：链表中链接结点的指针反转改变链表方向，然后从尾到头输出
 * 缺点：需要额外的操作
 * 方法二：遍历链表，每经过一个结点，就把该结点放到一个栈中
 * 遍历完后，从栈顶开始输出
 * 缺点：需要维护一个额外的栈空间
 * 方法三：递归，每访问一个结点，先递归输出它后面的结点，再输出该结点自身
 */

public class PrintListReversely {
    public static void printListReversely(Node pListHead){
        if(pListHead!=null){
            printListReversely(pListHead.next);
            System.out.println(pListHead.data);
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Node node1=new Node(2);
        Node node2=new Node(4);
        Node node3=new Node(1);
        node1.next=node2;
        node2.next=node3;

        printListReversely(node1);
    }

}