TLinkTLinkNodeTLinkNodeTLinkNodeTLinkNodeTLinkNodeTLinkNode

class TLinkNode>{

int size = 0;

TNode root = null;

TNode reverseRoot = null;

TNode reverseRootStack = null;

//查找链表中的结点

public TNode findNode(T data){

TNode p = root;

while(p != null){

if (p.getData() == data){

return p;

}

else{

p = p.getTail();

}

}

return null;

}

//返回根结点

public TNode findRoot(){

return root;

}

//返回使用递归反转后的根结点

public TNode findReverseRoot(){

return reverseRoot;

}

//返回使用栈反转结点的根结点

public TNode findReverseStackRoot(){

return reverseRootStack;

}

//链表使用栈进行反转(非循环链表)

public void ReverseRootStack(TNode node) {

TNode p = node;

Stack> stack = new Stack>();

while(p != null){

stack.push(p);

p = p.getTail();

}

while (!stack.isEmpty()){

TNode t = stack.pop();

t.setHead(null);

t.setTail(null);

if (reverseRootStack == null){

reverseRootStack = t;

}

else{

if (reverseRootStack.getTail() == null){

reverseRootStack.setTail(t);

t.setHead(reverseRootStack);

}

else{

TNode tt = null;

TNode pp = reverseRootStack;

while(pp != null){

tt = pp;

pp = pp.getTail();

}

tt.setTail(t);

t.setHead(tt);

}

}

}

}

//链表使用递归的方式进行反转(非循环链表)

public void printNodeDesc(TNode node){

int count = 0;

TNode p = node;

TNode t = null;

TNode tt = null;

while (p != null){

t = p;

p = p.getTail();

count++;

}

if (count == 0) {

return;

}

if (reverseRoot == null) {

t.getHead().setTail(null);

t.setHead(null);

reverseRoot = t;

}

else{

if (reverseRoot.getTail() == null){

t.getHead().setTail(null);

t.setHead(null);

reverseRoot.setTail(t);

t.setHead(reverseRoot);

}

else{

TNode pp = reverseRoot;

while (pp != null){

tt = pp;

pp = pp.getTail();

}

if (t.getHead() != null) {

t.getHead().setTail(null);

}

else{

node = null;

}

t.setHead(null);

tt.setTail(t);

t.setHead(tt);

}

}

printNodeDesc(node);

}

//打印链表中的每个结点

public void printNode(TNode node){

TNode p = node;

if (p != null){

//顺序输出

System.out.println("=== p.data ==>> " + p.getData() + ", p.head ==>> " + p.getHead() + ", p.tail ==>> " + p.getTail() + ", size ==>> " + size);

printNode(p.getTail());

//逆序输出

/*

System.out.println("=== p.data ==>> " + p.getData() + ", p.head ==>> " + p.getHead() + ", p.tail ==>> " + p.getTail() + ", size ==>> " + size);

*/

}

}

//判断链表中是否有循环结点

public T findCircle(TNode node){

TNode p = node;

TNode t = node;

while (p.getTail() != null){

p = p.getTail();

if (t.getTail().getTail() != null) {

t = t.getTail().getTail();

}

else{

return null;

}

if (p == t){

System.out.println("=== p.getData ==>> " + p.getData());

return p.getData();

}

}

return null;

}

//查找链表中的循环起点

public TNode findCircleData(TNode node){

TNode p = node;

List> list = new ArrayList<>();

while (p != null){

list.add(p);

for (int i = 0; i < list.size(); i ++){

if (list.get(i) == p.getTail()){

System.out.println("=== p.getTail.getData ==>> " + p.getTail().getData());

return p.getTail();

}

}

p = p.getTail();

}

return null;

}

/**

* 向链表中放入数据，此处只在链表尾端放入数据;

* 往链表头和链表中间插入数据逻辑都差不多，都是先查找到需要放入数据的结点,再改变新增数据前后的结点指针的指向；

* [@param](https://my.oschina.net/u/2303379) data

* [@return](https://my.oschina.net/u/556800)

*/

public boolean putData(T data){

size ++;

TNode node = root;

if(node == null){

//新建头节点，将第一个插入进来的数据作为链表的头结点

node = new TNode(data, null, null);

root = node;

}

else{

TNode p = node;

TNode t = node;

while(p != null){

t = p;

p = p.getTail();

}

TNode newData = new TNode(data, null, null);

t.setTail(newData);

newData.setHead(t);

/**

* 以下代码是将链表设置为循环链表，作测试使用

*/

/*

TNode pp = root;

if(size == 10){

while (pp != null){

if (pp.getData() == "banana"){

newData.setTail(pp);

break;

}

pp = pp.getTail();

}

}

*/

}

return true;

}

//从链表中更新结点

public boolean upData(T data, T newData){

TNode node = root;

while(node != null){

if (node.getData() == data){

node.setData(newData);

return true;

}

node = node.getTail();

}

return false;

}

//从链表中删除结点

public boolean delData(T data){

TNode node = root;

while(node != null){

if (node.getData() == data){

size --;

if (node == root){

if (node.getTail() != null){

root = node.getTail();

}

else{

root = null;

}

}

else{

//删除node结点

node.getHead().setTail(node.getTail());

node.getTail().setHead(node.getHead());

}

node.setHead(null);

node.setTail(null);

return true;

}

node = node.getTail();

}

return false;

}

}

//结点类

class TNode>{

private T data; //结点存储的数据

private TNode head; //结点头指针

private TNode tail; //结点尾指针

public TNode(T data, TNode head, TNode tail){

this.data = data;

this.head = head;

this.tail = tail;

}

public void setData(T data) { this.data = data; }

public void setHead(TNode head){ this.head = head; }

public void setTail(TNode tail){ this.tail = tail; }

public T getData(){ return this.data; }

public TNode getHead(){ return this.head; }

public TNode getTail(){ return this.tail; }

}