java 数据结构

package hello;




public class LinkListOperate {


private class Node{

private String data;
private Node next;

public Node(){

}
public Node(String data,Node next){

this.data=data;
this.next=next;
}
}

private Node header;
private Node tail;
private int size;

public LinkListOperate(){

header=null;
tail=null;

}

public LinkListOperate(String element){

header=new Node(element,null);
tail=header;
size++;
}


public void setCycle(){

tail.next=header.next;
}

public void add(String element){

if(header==null){

header=new Node(element,null);
tail=header;
}else{

Node newNode=new Node(element,null);

tail.next=newNode;

tail=newNode;
}
size++;
}


public void reverse(){  //反向输出一个链表, 正常情况，一个链表的前一个节点的next指向后一个节点，反向即后一个节点的next指向前一个节点。

Node prev=header;
Node qcurrent=header.next;
Node pnext=null;
while(qcurrent!=null){

pnext=qcurrent.next;   //保存当前变量
qcurrent.next=prev;   //将当前节点的next指向前一个节点
prev=qcurrent;    //当前节点变为前一个节点
qcurrent=pnext;   //下一个节点即为当前节点
}

header.next=null;
header=prev;
}



public void reverseRecursion(Node n1){   //使用递归函数，反向输出

//Node n1=header;

if(n1==null){
return;
}
else{
reverseRecursion(n1.next);   // 递归调用
System.out.print(n1.data);
}
}




public String middleList(){  //输出链表中间位置，两个指针，一个走一步，一个每次走两步，后面的到达终点后，第一个指针所在的位置就是中间

Node n1=header;
Node n2=header.next;

while(n2 != null){

n1=n1.next;   //一次一步
n2=n2.next.next;  //一次两步
}

return n1.data;

}


public boolean isCycle(){   //判断链表是否存在环路，两个指针，一个每次一步，一个每次两步，如果两个相遇（即相等），则存在环路

Node n1=header;
Node n2=header.next;
while(n2!=null){

n1=n1.next;
n2=n2.next.next;
if(n2==n1){

return true;
}
}
return false;
}


public String findRKNode(int k){   //查找倒数第K个节点



Node n1=header;
Node n2=header;
for(int i=0;i<=k;i++){

n1=n1.next;
}

while(n1!=null){

n1=n1.next;
n2=n2.next;
}


return n2.data;
}


public boolean isCrossing(Node a,Node b){   //判断两个链表是否相交，  如果相交，最后一个节点肯定是共有的。

if(a==null||b==null){

return false;
}

Node n1=a;
while(n1.next!=null){   //循环到最后一个节点

n1=n1.next;
}

Node n2=b;
while(n2.next!=null){  //循环到最后一个节点
n2=n2.next;
}

return n1==n2;     //判断最后一个节点是否相等


}



public Node theFirstCrossNode(Node a,Node b){   //判断两个链表相交的第一个节点

if(a==null|b==null){

return null;
}

Node n1=a;
int len1=1;
while(n1.next!=null){

n1=n1.next;
len1++;
}

Node n2=b;
int len2=1;
while(n2.next!=null){

n2=n2.next;
len2++;
}

if(n1!=n2){                   //先判断有没有相交，如果没有，返回null

return null;
}

Node n11=a;
Node n22=b;
if(len1>len2){            //如果有相交，如果第一个链表长度长，则先走到len1-len2,然后两个一块走，如果相等则是第一个交点

int k=len1-len2;
while(k>0){

n11=n11.next;
k--;
}
}else{

int k=len2-len1;
while(k>0){

n22=n22.next;
k--;
}
}

while(n11!=n22){

n11=n11.next;
n22=n22.next;
}

return n22;

}




public Node theFirstCycleNode(Node a){          //单链表环路，进入环路的第一个节点

if(a==null||a.next==null){

return null;
}

Node nFast=a;
Node nSlow=a;
while(nFast!=null && nFast.next!=null){      //先判断是否存在环路，一旦存在环路，则中断，此时的节点在环中的某个节点

nSlow=nSlow.next;
nFast=nFast.next.next;
if(nSlow==nFast){

break;
}
}

if(nFast==null || nFast.next==null){

return null;
}

Node assumTail=nSlow;              //假设环中的节点作为尾节点， 这样就变为两个链表的相交问题，同上一函数
Node header1=header;   
Node header2=assumTail.next;   //设置两个链表的header

int len1=1;
Node n1=header1;
while(n1!=assumTail){   //终点为环中的尾节点

n1=n1.next;
len1++;
}

int len2=1;
Node n2=header2;
while(n2!=assumTail){

n2=n2.next;
len2++;
}

Node n11=header1;
Node n22=header2;

if(len1>len2){

int k=len1-len2;
while(k>0){

n11=n11.next;
k--;
}
}else{

int k=len2-len1;
while(k<0){

n22=n22.next;
k--;
}
}

while(n11!=n22){

n11=n11.next;
n22=n22.next;
}

return n11;
}

public String toString(){



StringBuilder sb=new StringBuilder("[");

for(Node current=header;current!=null;current=current.next){

sb.append(current.data.toString()+",");
}

int length=sb.length();


return sb.delete(length-1, length).append("]").toString();


}





public static void main(String[] args) {
// TODO Auto-generated method stub


LinkListOperate llo=new LinkListOperate();
llo.add("a");
llo.add("b");
llo.add("c");
llo.add("d");
llo.add("e");
//llo.setCycle();

LinkListOperate llo1=new LinkListOperate();
llo1.add("a");

llo1.add("d");
llo1.add("e");

//llo1.header.next=llo.header.next.next;   //设置两个链表相交

//System.out.println("is crossing?"+llo1.isCrossing(llo.header, llo1.header));
//System.out.println("The first crossing node:"+llo1.theFirstCrossNode(llo.header,llo1.header).data);


//System.out.println("is cycle?"+llo.isCycle());
//System.out.println("This first cycle node:"+llo.theFirstCycleNode(llo.header).data);
/*llo.reverse();

llo.reverseRecursion(llo.header);
System.out.println();

System.out.println(llo.middleList());
System.out.println(llo.findRKNode(2));
System.out.println(llo);*/

}


}