数据结构(java语言描述)链表的使用

１．定义node类，实现Node结点的构造函数（空结点和指定数值的结点），基本的获取结点的指针域，数据域，设置指针域，数据域。

package class2;
public class Node {
private Object data;
private Node next;
//无参构造函数
 public Node(){
    // this(null,null);
     this.data=null;
     this.next=null;
 }
 //带一个参数的构造函数
 public Node(Object data){
     //this(data,null); //效果同下
     this.data=data;
     this.next=null;
 }
 //带两个参数的构造函数
public Node(Object data,Node next) {
this.data=data;
this.next=next;
}
 //获取当前结点的数据
public Object getData(){
    return data;
}
//获取当前结点的指针域
public Node getNext(){
    return next;
}
//为当前结点赋值
public void setData(Object data){
    this.data=data;
}
//修改当前结点的指针域
public void setNext(Node next){
    this.next=next;}}

２．定义链表类，实现了链表的创建（头插法和尾插法），计算链表长度，查询连表中第i个结点的值，返回连表中值为X的结点所在的位置，

删除下标为i的结点，在链表的指定位置插入值为X的结点，清空链表，遍历整个链表等方法。

package class2;
import java.util.Scanner;
public class LinkList {
    private Node head;
    //LinkList初始化头结点
    public LinkList(){
        head=new Node();
    }
    //带有两个参数的构造函数
    public LinkList(int n,boolean Order) throws Exception{
        this.head=null;
        if(Order){//带头结点的头插法
            create(n);    
        }else
            create1(n);
    }
    //返回链表的长度
    public int length(){
    Node p=head;//头结点作为链表的第-1个结点
    int j=-1;
    while(p!=null){
        p=p.getNext();
        j++;
    }
    return j;
    }
    //返回连表中第i个结点的值
    public Object get(int i) throws Exception{
        Node p=head;
        int j=-1;
        while(p!=null&&j<i-1){//找到第i个结点,下标为i-1
            p=p.getNext();
            j++;
        }
        if(p==null||j>i-1) throw new Exception("输入的位置不合法！");
        return p.getData();
        
    }
    //返回链表中第一个等于x的结点的位置
    public int IndexOf(Object x){
        Node p=head.getNext();
        int j=0;//此时p指的是下标为０的结点
        while(p!=null&&!(p.getData().equals(x))){
            p=p.getNext();
            ++j;
        }
        if(p!=null)
            return ++j;
        else
            return -1;
    }//为什么x是第一个结点时返回的数值是3
    //删除链表中的下标为i结点
public void delete(int i) throws Exception{
    Node p=head;
    int j=-1;//把头结点作为链表的第i-1个结点 1
    while(p.getNext()!=null&&j<i-1){//寻找第i个结点的前驱结点
    p=p.getNext();
    j++;
    }
    if(j>i-1||p.getNext()==null)
            throw new Exception("删除位置不合法");
    p.setNext(p.getNext().getNext());//把第i-1个结点的指针域设为第i-1个结点的后继的后继结点的指针
    //即把第i个结点删除掉
}
    //向链表的第i个位置插入新的结点
    public void insert(int i,Object x)throws Exception{
        Node p=head;
        int j=-1;
        while(p!=null&&j<i-1){//寻找第i个结点的前驱
            p=p.getNext();
            ++j;
        }
        if(j>i-1||p==null)
            throw new Exception("插入的位置不合法");
        Node s=new Node(x);
        s.setNext(p.getNext());//把第i-2个结点的后继，即第i-1个结点的指针赋给s
        p.setNext(s);//此时s成为第i-1个结点
    }
    //头插法创建一个有n个结点的链表
    public void create(int n) throws Exception{
        Scanner sc=new Scanner(System.in);
        for(int i=0;i<n;i++){//依次插入n个结点
            insert(0,sc.next());//可以直接调用方法,此时是把生成的新结点插入倒表头
        }
    }
    //尾插法创建一个有Ｎ个结点的链表
    public void create1(int n)throws Exception{
        Scanner sc=new Scanner(System.in);
        for(int j=0;j<n;j++){//依次插入n个结点
            insert(length(),sc.next());//每次把新生成的结点插入到表尾
        }    
    }
    public void clear(){
        head.setNext(null);
        head.setData(null);
    }
    public void display(){
        Node p=head.getNext();
        while(p!=null){
            System.out.println(p.getData());
            p=p.getNext();
        }
    }
}

３．在程序中实例化链表，并对链表做初始化，遍历，插入，查询等操作。

package class2;
public class li2 {
public static  void main(String[] args) throws Exception{
    LinkList s=new LinkList();
    System.out.println("链表S的长度是:"+s.length());
    s.create(3);
    s.display();
    System.out.println("链表S的第２个结点是:"+s.get(2));
    System.out.println("链表S的值为Lily的结点是第？个:"+s.IndexOf("Lily"));
    System.out.println("链表S的长度是:"+s.length());
    s.delete(1);
    System.out.println("链表S的长度是:"+s.length());
    s.display();
}
}

转载于:https://www.cnblogs.com/xleer/p/5288193.html