单链表的初步实现---（转置，删除，替换，查找，添加）

class Link{                                     //定义链表
private class Node{                         //定义保持的节点
private Object data;                    //要保持的数据，可以用泛型替代
private Node next;                      //保持下一个节点信息
public Node(Object data){
this.data = data;
}
public void addNode(Node newNode) {
if(this.next == null){              //如果下一个节点为空，则保持节点，如果不为空，则找到空为止
this.next = newNode;
}else{
this.next.addNode(newNode);
}
}
public Object getNode(int index) {
if(Link.this.flag ++ == index){     //从第一个下标数据开始查询，如果和查询的索引为止一样，则返回当前数据，找不到则继续往后查询
return this.data;
}else{
return this.next.getNode(index);
}
}
public void setNode(int index,Object data) {
if(Link.this.flag ++ == index){     //  和get方法是一样的，找到和索引相等位置的数据则修改数据
this.data = data;
}else{
this.next.setNode(index,data);
}
}
public boolean containsNode(Object data) {
if(this.data.equals(data)){         //  从第一个数据开始比对，如果比对到，则返回数据，如果下一个节点还存在则继续比对，如果下个节点不存在则返回false，找到返回true
return true;
}else{
if(this.next!=null){
return this.next.containsNode(data);
}
}
return false;

}
public void removeNode(Node node, Object data) {
if(this.data.equals(data)){         //找到要删除的数据的节点，比如  1-->2-->3    2 节点找到，则把指向改为1-->3
node.next = this.next;
}else{
this.next.removeNode(this, data);   //没找到数据则继续往后查询，this表示当前对象  第一次：this.root.next 第二次: this.root.next.next ...
}
}
public void toArrayNode() {
Link.this.retArray[Link.this.flag++] = this.data ;  //数组保持数据
if(this.next !=null){
this.next.toArrayNode();
}
}
public Node transposeNode(Node node) {      //链表转置   将1-->2  2--->3  变更为 2-->1  3--->2
Node first =node;
Node second = node.next;                //为转置做准备
Node third = null;
while(second!=null){
third = second.next ;               //保持2-->3的节点信息
second.next = first;                //将1--->2 变成2--->3
first = second;                     //为下一次替换做准备
second = third;
}
node.next = null;
node = first;
return node;
}
}
private Node root = null;                       //定义根节点
private int count = 0 ;                         //统计数量
private int flag = 0;                           //定义下标
private Object[]  retArray;                     //保持数据
public void add(Object data){                   //添加数据
if(data == null){
return ;
}
Node newNode = new Node(data);
if(this.root == null){
this.root = newNode;
}else{
this.root.addNode(newNode);
}
this.count++;
}
public boolean isEmpty(){                       //判断是否空
return this.count==0 && this.root==null;
}
public int size(){                              //取得链表长度
return this.count;
}
public Object get(int index){                   //取得指定索引的数据
if(this.isEmpty()){
System.out.println("链表为空，无法取值。");
return null;
}
if(index >= this.count){
System.out.println("输入的索引位置超过链表长度，请重新输入。");
return null;
}
this.flag = 0;
return this.root.getNode(index);
}
public void set(int index,Object data){         //将指定索引的数据变更
if(this.isEmpty()){
System.out.println("链表为空，无法取值。");
return ;
}
if(index >= this.count){
System.out.println("输入的索引位置超过链表长度，请重新输入。");
return ;
}
this.flag = 0;
this.root.setNode(index,data);
}
public boolean contains(Object data){           //查找数据是否存在
if(data == null){
System.out.println("输入的数据为空，无法查找。");
return false;
}
if(this.isEmpty()){
System.out.println("链表为空。");
return false;
}
return this.root.containsNode(data);
}
public boolean remove(Object data){             //删除数据
if(!(this.contains(data))){
System.out.println("要删除的数据不存在。");//删除前先确认下数据是否存在
return false;
}
if(this.root.data.equals(data)){
this.root = this.root.next;
}else{
this.root.next.removeNode(this.root,data);
}
this.count--;
return true;
}
public Object[] toArray(){                      //保存数据
if(this.isEmpty()){
System.out.println("链表为空。");
return null;
}
this.retArray = new Object[this.count];
this.flag = 0;
this.root.toArrayNode();
return retArray;
}
public void transpose(){                        //链表转置
if(this.isEmpty()){
System.out.println("链表为空。");
return ;
}
this.root = (this.root.transposeNode(this.root));
}
}
public class Test{                              //定义测试类
public static void main(String args[]){
Link all = new Link();
all.get(1);
all.add("数据A");
all.add("数据B");
all.add("数据C");
all.add("数据D");
all.add("数据E");
System.out.println("链表是否为空："+all.isEmpty()+"链表的长度："+all.size());
System.out.println("第三个数据是："+all.get(2));
all.set(2, "数据修改");
System.out.println("修改后的数据是："+all.get(2));
all.remove("数据修改");
System.out.println("查询数据是否存在："+all.contains("数据修改"));
Object[] obj = all.toArray();
for (int i=0; i<obj.length;i++){
String str = (String)obj[i];
System.out.println(str);
}
all.transpose();
System.out.println("链表是否为空："+all.isEmpty()+"链表的长度："+all.size());
Object[] obj1 = all.toArray();
for (int i=0; i<obj1.length;i++){
String str = (String)obj1[i];
System.out.println(str);
}
}
}