数据结构之单链表的实现-java

一、单链表基本概念

单链表是一种链式存取的数据结构，用一组地址任意的存储单元（一般是非连续存储单元）存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素data + 指针next(指示后继元素存储位置)。其存储结构如图：

二、JAVA实现单链表

数据结构：

单链表有一个属性head和一些重要的方法，head为链表结点Node类的实例。Node类中包含成员变量：data，next。data为当前节点的数据域，next为指针域，指向下一个结点。

1、结点

 class Node{
     int data;
     Node next=null;
     public Node(int data){
         this.data=data;
     }
     public Node(){}
     public void display() {
         System. out.print(this.data + " ");  //结点打印函数
    }
 }

2、单链表

 public class linkList {
     Node head=new Node();
     //各种方法的实现代码
 }

函数

1、链表添加元素之头插

每次来了新元素将其插入到头结点之后

 public void insertHead(int val){
         Node newnode=new Node(val);
         if(head.next!=null){
             newnode.next=head.next;
         }
         head.next=newnode;
 }

2、链表添加元素之尾插

每次来了新元素将其插入到链表最后位置

 public void insertTail(int val){
         Node newnode=new Node(val);
         Node walkPointer=head;
         while(walkPointer.next!=null){
             walkPointer=walkPointer.next;
         }
         walkPointer.next=newnode;
 }

3、任意位置插入

 public void insert(int pos,int val){
         int index=0;
         if(pos>=0&&pos<=this.getLength()){
             Node walkPointer=head;
             while(index!=pos){
                 walkPointer=walkPointer.next;
                 index++;
             }
             Node newnode=new Node(val);
             newnode.next=walkPointer.next;
             walkPointer.next=newnode;
         }
 }

4、获取链表长度

 public int getLength(){
         int length=0;
         Node walkPointer=head;
         while(walkPointer.next!=null){
             walkPointer=walkPointer.next;
             length++;
         }
         return length;
 }

5、删除指定结点(头指针未知)：实质用该结点代替其next结点

 public boolean delete(Node delnode){
         if(delnode==null||delnode.next==null){
             return false;
         }
         delnode=delnode.next;
         return true;
 }

6、遍历链表

 public void print() {
         Node walkPointer=head;
         System.out.println("**链表结点遍历**");
         while(walkPointer.next!=null){
             walkPointer=walkPointer.next;
             System.out.print(walkPointer.data + " ");
         }
         System.out.println();
 }  

7、链表逆置

之前遇到一道题目，需要将链表元素从尾到头创建ArrayList数组的题目，这里相同的思路，只不过是逆序输出创建新的链表。

两者不同之处在于：对于非递归的方式，链表逆序输出创建新数组时，采用头插的方式相对费时，需要将第一个元素之后的元素后移；而链表逆序输出创建新链表时，采用头插的方式相对快速，只要找到头结点即可一步插入。相反的，对于递归的方式，链表逆序输出创建新数组时，采用尾插的方式相比创建新链表要省时。

思路1：（递归）将链表结点的数据顺序取出存储在栈中——从栈中pop元素采用尾插的方式建立新链表（链表的尾插比较费时，需要遍历到链表最后一个元素才能插入元素）

public linkList reverse1(){
        linkList list=new linkList();
    Stack<Integer> stack=new Stack<Integer>();
    Node walkPointer=head.next;
    while(walkPointer!=null){
            stack.push(walkPointer.data);
            walkPointer=walkPointer.next;
        }
    while(!stack.empty()){
               list.insertTail(stack.pop());
        }
    return list;
}

思路2：（非递归）声明新链表，将原链表元素顺序取出，同时采用头插的方式插入到新链表中（链表的头插相对于尾插耗时更小）

 public linkList reverse(){
         linkList list=new linkList();
         Node walkPointer=head.next;
         Node temp=new Node();
         while(walkPointer!=null){
             list.insertHead(walkPointer.data);
             walkPointer=walkPointer.next;
         }
         return list;
 }

整体代码（含测试）

 package struct;
 
 import java.util.Stack;
 
 class Node{
     int data;
     Node next=null;
     public Node(int data){
         this.data=data;
     }
     public Node(){}
     public void display() {
         System. out.print(this.data + " ");  //结点打印函数
    }
 }
 public class linkList {
     Node head=new Node();
     //头插
     public void insertHead(int val){
         Node newnode=new Node(val);
         if(head.next!=null){
             newnode.next=head.next;
         }
         head.next=newnode;
     }
 
     //尾插
     public void insertTail(int val){
         Node newnode=new Node(val);
         Node walkPointer=head;
         while(walkPointer.next!=null){
             walkPointer=walkPointer.next;
         }
         walkPointer.next=newnode;
     }
 
     //获得链表长度
     public int getLength(){
         int length=0;
         Node walkPointer=head;
         while(walkPointer.next!=null){
             walkPointer=walkPointer.next;
             length++;
         }
         return length;
     }
 
     //任意位置插入
     public void insert(int pos,int val){
         int index=0;
         if(pos>=0&&pos<=this.getLength()){
             Node walkPointer=head;
             while(index!=pos){
                 walkPointer=walkPointer.next;
                 index++;
             }
             Node newnode=new Node(val);
             newnode.next=walkPointer.next;
             walkPointer.next=newnode;
         }
     }
 
     //链表的逆置（非递归，同从尾到头构建列表，链表的头插复杂度比列表头插低很多）
     public linkList reverse(){
         linkList list=new linkList();
         Node walkPointer=head.next;
         Node temp=new Node();
         while(walkPointer!=null){
             list.insertHead(walkPointer.data);
             walkPointer=walkPointer.next;
         }
         return list;
 //笨方法
 //        Node preNode=head;
 //        Node walkPointer=head.next;
 //        head.next=null;
 //        Node nextNode=new Node();
 //        while(walkPointer!=null){
 //            nextNode=walkPointer.next;
 //            walkPointer.next=preNode;
 //            preNode=walkPointer;
 //            walkPointer=nextNode;
 //        }
 //        list.head.next=preNode;
 //        return list;
     }
 
     //链表的逆置（递归，使用栈。类似于从尾到头输出列表）
     public linkList reverse1(){
         linkList list=new linkList();
         Stack<Integer> stack=new Stack<Integer>();
         Node walkPointer=head.next;
         while(walkPointer!=null){
             stack.push(walkPointer.data);
             walkPointer=walkPointer.next;
         }
         while(!stack.empty()){
                list.insertTail(stack.pop());
         }
         return list;
     }
 
     //删除指定结点(头指针未知)，实质用该结点代替其next结点
     public boolean delete(Node delnode){
         if(delnode==null||delnode.next==null){
             return false;
         }
         delnode=delnode.next;
         return true;
     }
 
     //打印遍历
     public void print() {
         Node walkPointer=head;
         System.out.println("**链表结点遍历**");
         while(walkPointer.next!=null){
             walkPointer=walkPointer.next;
             System.out.print(walkPointer.data + " ");
         }
         System.out.println();
     }
     @SuppressWarnings("null")
     public static void main(String []args){
         linkList list=new linkList();
         list.insertHead(12);
         list.insertHead(15);
         list.insertHead(2);
         list.insertHead(3);
         list.insert(0,4);
         list.print();
         System.out.println("链表长度");
         System.out.println(list.getLength());
         System.out.println("！！链表转置后的头结点数据！！");
         linkList returnlist=new linkList();
         returnlist=list.reverse();
         returnlist.print();
         returnlist=list.reverse1();
         returnlist.print();
     }
 }