Circular List

一.环形列表：列表中任何一个节点可以到达其他节点。

1.插入：插入有俩中形式，第一种：插入到第一个节点之前，第二种：插入到列表中任何一个节点中

2.删除：删除X 是第一个节点，最后一个节点链接到X第一个节点后面；第二种：列表中间节点，X前节点链接X后一个节点。

有关于内存分配的运用。

http://blog.csdn.net/yangyuankp/article/details/7651251

package CircularList;


//环形列表，
//插入有俩中形式，第一种：插入到第一个节点之前，第二种：插入到列表中任何一个节点中
public class circulist {

    
    public Node first;
    public Node last;
    
    public boolean isEmpty()
    {
        return first==null;
    }
    
    public void print()
    {
        Node current=first;
        while(current!=last)
        {
            System.out.println("["+current.data+"]");
            current=current.next;
        }
        System.out.println("["+current.data+"]");
        System.out.println(current.next);//Circular List 
        System.out.println();
    }
    
    public void insert(Node trp)
    
    {
        //插入两种方式，插入到第一个节点，或者插入到最后一个节点
        Node newNode;Node tmp;
        if(this.isEmpty())
        {
            first=trp;
            last=trp;
        }
        else if(trp.next==null)
        {
            //插入第一个节点之前
            last.next=trp;
            last=trp;
            last.next=first;
        }
        else
        {
            //插入到中间
            newNode=first;
            tmp=first;
            while(newNode.next!=trp.next)
            {
                if(tmp.next==first)
                    break;
                
                newNode=newNode.next;
                tmp=newNode;
            }
            tmp.next=trp;//发现在测试的时候出现trp点有所有节点信息。
            
        }
    }
    public static void main(String[] args)
    {
        circulist cir=new circulist();
        //建立5个数据环形列表
        for (int i=1;i<=5;i++)
        {    Node tmp=new Node(i);
            cir.insert(tmp);
            
        }
        cir.print();
        
        int insertposi=2;int i=1;
        Node insertNode=new Node(6);
        
        circulist cir2= new circulist();//直接与堆中地址相连
        cir2=cir;
        
        Node current=cir2.first;
        System.out.println(current);
        
        while(i<=insertposi)
        {
            System.out.println(current);
            current=current.next;
            i++;
        }
        //current.next=null;这句话不能用，在这里修改current同时会修改first列表
        
        cir.print();
        insertNode.next=current;
        System.out.println("被插入点"+insertNode.data);
        
            
        
        cir.insert(insertNode);
        System.out.println("在中间插入");
        cir.print();
    }
}

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

[1]
[2]
[3]
[4]
[5]
CircularList.Node@1db9742

CircularList.Node@1db9742
CircularList.Node@1db9742
CircularList.Node@106d69c
[1]
[2]
[3]
[4]
[5]
CircularList.Node@1db9742

被插入点6
在中间插入
[1]
[2]
[6]
[3]
[4]
[5]
CircularList.Node@1db9742

对于链表删除

package CurListLinnk;

public class StudentLinkList {

    public Node first;
    
         public Node last;
        
         public boolean isEmpty()
        {
              return first==null;
          }
          
         public void print()
         {
             Node current=first;
             while(current!=last)
            {
                System.out.println("["+current.data+"]");
                current=current.next;
              }
            System.out.println("["+current.data+"]");
         System.out.println(current.next);//Circular List 
              System.out.println();
        }
         
        public void insert(Node trp)
         
        {
            //插入两种方式，插入到第一个节点，或者插入到最后一个节点
            Node newNode;Node tmp;
            if(this.isEmpty())
            {
            first=trp;
                 last=trp;
             }
             else if(trp.next==null)
             {
                 //插入第一个节点之前
                last.next=trp;
                last=trp;
                last.next=first;
             }
            else
              {
                //插入到中间
                newNode=first;
                 tmp=first;
                while(newNode.next!=trp.next)
                {
                    if(tmp.next==first)
                        break;
                   
                newNode=newNode.next;
                 tmp=newNode;
                 }
                tmp.next=trp;//发现在测试的时候出现trp点有所有节点信息。
                 
             }
        }
        public void delete (int position)
        {
            Node tmp=first,frontNode=first;
            int i=0;
            while(i<position)
            {    
                frontNode=tmp;
                tmp=tmp.next;
                i++;
                 System.out.println(frontNode.data);
            }
            frontNode.next=tmp.next;
            
        }
        public static void main(String[] args)
        {
                StudentLinkList cir=new StudentLinkList();
                     //建立5个数据环形列表
                     for (int i=1;i<=5;i++)
                     {    Node tmp=new Node(i);
                          cir.insert(tmp);
                         
                      }
                     System.out.println("删除之前");
                      cir.print();
                      cir.delete(2);
                      cir.print();
        }
}


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

删除之前
[1]
[2]
[3]
[4]
[5]
CurListLinnk.Node@1db9742

1
2
[1]
[2]
[4]
[5]
CurListLinnk.Node@1db9742

 

双向链表：一个节点有三个字断：LLink--Data---RLink，LLink指向前一个节点，RLink指向后一个节点，与单方向节点差不多