LinkList

第一节:单向链表:链表数据存储原有数据还有下一个数据的地址，用指针

　　链表有许多相同类型的元素按照特定的顺序排列形成的线性表，最重要两个操作 插入、删除。优点:插入和删除十分方便。

在java中模拟节点，采用class建立一个节点，只能采用类代替C++中指针，只能够用first，last两个

Node类点节点来表示指针。

class Node{
    int Data;
    Node next;//C语言中运用的是指针
    
    //构造函数初始化
    public Node(int Data)
         {
    this.Data=Data;this next=Null;
    }    

}        

在java中没有指针类型，只能够用类代替指针。C++通过申请地址来进行下一个节点的链接。

BuffereadReader java中一个缓冲内，从外界输入的值先放入缓冲中，在写入内存，防止外界输入的被失去。

建立单向链表，包括其中插入和删除方法：

package linklist;
import java.io.*;
public class CH03_1 {

    
    public static void main(String[] args) throws  IOException {
        // TODO Auto-generated method stub
        BufferedReader buff;//防止外界的值输入过快被舍弃
        buff=new BufferedReader(new InputStreamReader(System.in));
        
        int num;String name;int score;
        LinkList list=new LinkList();//本包之中Node中LinkList类
        System.out.println("输入5位同学的数据");
        for(int i=1;i<6;i++)
        {
            System.out.println("input the Student number:");
            num=Integer.parseInt(buff.readLine());
            
            System.out.println("input the Student name:");
            name=buff.readLine();
            
            System.out.println("input the Student Score:");
            score=Integer.parseInt(buff.readLine());
            
            
            list.Insert(score, name, num);
                    
        }
        list.print();
        Node delNode=new Node("xiao ming",70,3);
        list.remove(delNode);
        list.print();
        
    }

}

 class Node {
    String name;
    int score,no;
    Node next;
    
    //构造函数初始化，模拟单个小节点
    public Node(String name,int score,int no)
    {
        this.name=name;
        this.score=score;
        this.no=no;
        this.next=null;
    }
}

class LinkList{
    //这两个东西表示指针
    private Node first;
    private Node last;
    public boolean isEmpty()
    {
        return first==null;
    }
    
    public void Insert(int Data,String name,int np)
    {
        Node newNode=new Node(name,Data,np);
        if(this.isEmpty())
        {
            this.first=newNode;
            this.last=newNode;
        }
        else
        {
            this.last.next=newNode;
            last=newNode;
        }
    }
    public void remove(Node delNode)
    {    Node newNode,tmp;
        //分为最前，中间和末尾三种方式删除
        if(first.no==delNode.no)
        {
            first=first.next;
        }
        else if(delNode.no==last.no)
        {
            //删除最后一个节点
            newNode=first;
            while(newNode.next!=last)
                newNode=newNode.next;
            newNode.next=last.next;//指针移动到倒数第二个节点位置上，更新最后一个节点
            last=newNode;
            
            
        }
        else
        {
            newNode=first;tmp=first;
            while(newNode.no!=delNode.no)
            {
                tmp=newNode;//截止条件在于newNode.no=delNode.no
                newNode=newNode.next;
                
            }
            System.out.println("newNode"+newNode.name);
            tmp.next=delNode.next;
        }
    }
    public void print()
    {
        Node current=first;
        while(current!=null)
        {
            System.out.println("["+current.no+current.name+current.score+"]");
            current=current.next;
        }
        System.out.println();
    }
}

 //对单向列表反向，特别注意其中的反向：

package linklist;

public class CH03_03 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
　　　　　　//写入函数进行test
    }

}

class ReverseStudentLinkList extends StudentList{
    //子类继承父类运用父类的方法：
    public void print()
    {
        Node front=null;
        Node current=first; 
        Node nextNode=null;
        
        System.out.println("链表反向");
        while(current!=null)
        {
            nextNode=current.next;//保存正向的顺序
            current.next=front;
            //向前移动
            front=current;
            current=nextNode;

            
            
        }
        
        //查看书上的利用first，current，last节点
        while(current!=null)
        {
            last=front;
            front=current;
            current=current.next;
            front.next=last;
        }
        
        //j接下来直接遍历
        current=front;
        
        while(current!=null)
        {
            System.out.println("["+current.no+current.name+current.score);
            current=current.next;
        }
        System.out.println();
        
        
    }
    
}