链表的实现以及链表的反转

链表？到底是个什么玩意儿？用它拿来干嘛？

链表其实跟数组一样，都是用来存储某一组数据的。我都有数组了，还要链表干嘛啊。其实得从它们的存储结构来看，链表跟数组最大的区别就是链表在内存中存储并不是连续存储的，而数组在内存中是一块连续的内存地址，它们都是用来存储数据的，但是由于它们的存储结构差异，因而导致了它们存在本质的区别。

数组在内存中大概是这个样子的：

而链表在内存中大概是这个样子哒：

我们可以清楚的看出来它们本质的差别，数组是一块连续的区域，它的这种存储结构使得它读取数据以及修改数据非常的方便，只需要靠下标来进行读取和修改。而链表就不一样了，它在内存中不是连续的，它也没有下标，那么它怎么实现对数组的操作，其实每一个链表都有一个头指针，他指向链表的头一个结点(就是上图中的一块蓝色区域它分为数据区跟指针区)，而结点的指针区指向下一个节点，我们只要知道链表的头结点就可以顺藤摸瓜，将整个链表都给数据都遍历一遍。如你所见，链表读取数据不如数组方便，假如你要读取第三个结点的数据你就需要从头结点开始慢慢往后读。但是链表的存在自然有它的特别之处，接下来我就来讲一讲它的特别之处。

假如我们现在有一个数组和一个链表，我们现在需要在第二个位置插入一个数，那么对于数组来说，他后面的所有元素是不是都要往后移动一个位置？

而对于链表来说就没那么复杂了，我们只需要改一下结点指针域的指向。

这就是它们本质的区别，可以说它们是各有各的长处，至于说你在存储数据时到底采用哪一种，那需要根据你实际的业务需求量，如果你是在一组数据的中间增加或者删除数据的情况多的话，那么当然是采用链表好一些。

如何用代码实现链表？我们一步一步来。

第一步当然是创建一个结点类型，他分为数据域和指针域，指针域用来存储下一个结点的位置。其中Number，Name，age都是数据域，next就是指向下一个结点的指针域。

class MyNode{
    public int Number;
    public String Name;
    public int age;

    public MyNode next;
   
    public MyNode(int Number,String name,int age){
        this.age = age;
        this.Name = name;
        this.Number = Number;
    }
    public MyNode(){};

    @Override
    public String toString() {
        return "MyNode{" +
                "Number=" + Number +
                ", Name='" + Name + '\'' +
                ", age=" + age +
                '}';
    }
}

然后就是创建一个List，一个链表必须要有头结点，头结点可以是空的，不存放数据仅代表链表的开头：

MyNode head = new MyNode();

然后就是为链表添加数据，一般是添加在链表的尾部，假如说我要为链表添加一个数据域为3的结点：

最后一个结点的指针域为空。代码的具体实现过程是这样的，首先我们需要一个辅助指针，他指向链表的头结点，然后通过遍历来到链表的最后一个结点，将最后一个结点的指针域指向新的结点。

public void Addnode(MyNode myNode){
        MyNode temp = head;
        while(true){
            if(temp.next == null){
                temp.next = myNode;
                break;
            }
            temp = temp.next;
        }
    }

插入结点：

其实跟添加结点的操作差不多，但是他要复杂一点，因为要是在链表中间插入结点的话需要新结点的指针域更新为原来结点的后面一个结点。

代码：

node.next = temp.next;//将需要插入的结点的指针域更新为要插入位置的后面一个结点的位置
temp.next = node;//将当前结点的指针域更新为要插入结点的位置

更新结点：找到需要更新的结点，直接修改里面的数据就可以了，我这里是根据结点的Number来的，找到序号相同的结点，然后更新里面的数据。

 public void update(MyNode node){
        MyNode temp = head;
        boolean flag = false;
        while(true){
            temp = temp.next;
            if(temp == null){
                flag = true;
                break;
            }
            if(temp.Number == node.Number){
                temp.Name = node.Name;
                temp.age = node.age;
                break;
            }
        }
        if(flag){
            System.out.printf("没有找到Number为：%d的节点",node.Number);
        }
    }

删除结点：我们需要找到要删除的结点的前一个结点，注意这里是要删除结点的前一个结点，然后将它的指针域更新到当前结点的后一个结点的后一个结点，然后要删除的结点没有引用指向它，就会被垃圾回收器回收。我这里的代码依然是根据Number来删除的结点。

  public void DelNode(int Number){
        MyNode temp = head;
        boolean flag = false;
        while(true){
            if(temp.next == null){
                flag = true;
                break;
            }
            if(temp.next.Number == Number){
                temp.next = temp.next.next;
            }
            temp = temp.next;
        }
        if(flag){
            System.out.printf("Not Found Number:%d",Number);
        }
    }

实现了链表的增删改，接下来我们就说一下链表的遍历，还是比较容易的，用一个循环就可以了。

  public void printLinkedList(){
        MyNode temp = head;

        while(true){
            temp = temp.next;
            if(temp == null){
                break;
            }
            System.out.println("number:"+temp.Number+" name:"+temp.Name+" age:"+temp.age);
        }
    }

链表的基本操作已经实现，接下来我们看一下几道思考题：

1，单链表的反转：

我的思想是这样的，我先定义了一个反转链表的头结点，然后遍历原来的链表，每遍历一个结点，就将它插到反转链表的头结点的后面。

  //实现单链表的反转
    public void ReverseLinkList(){
        //首先判断是不是空或者只有一个节点
        if(head == null || head.next.next == null){
            return;
        }
        MyNode temp = head.next;
        MyNode reversrHead = new MyNode();
        MyNode next; //记录原链表下一个值
        MyNode myNode;   //记录反转链表下一个值
        //遍历链表
        while(true){
            if(temp == null){
                break;
            }
            //node = temp;
            next = temp.next;
            myNode = reversrHead.next;  //第一个为null
            reversrHead.next = temp; //在反转头结点的后面插入一个结点 
            reversrHead.next.next = myNode;   //然后将插入结点的指针域更新
            temp = next;
        }
        head = reversrHead;
    }

2，倒叙打印链表：

比较结点利用一下栈就可以了。

 //倒叙打印链表
    public static void PrintReversrList(MyNode head){
        if(head == null){
            return;
        }
        Stack<MyNode> stack = new Stack<>();
        MyNode cur = head.next;
        while(cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        while(!stack.isEmpty()){
            System.out.println(stack.pop());
        }
    }

3，打印链表的倒数第K个结点：

我是这样做的，首先遍历链表，获取链表的总长度，然后利用总长度减去K就是我们正序要打印的结点。

  //打印链表的倒数第K个节点
    public static void PrintKNode(MyNode head,int k){
        if(head == null){
            return;
        }
        //获取链表的总长度
        int ListLength = 0;
        MyNode temp = head.next;
        while(temp != null){
            ListLength++;
            temp = temp.next;

        }
        //然后用总长度减去倒数第K个节点就是要打印的节点
        temp = head.next;
        for(int i=0;i<ListLength-k;i++){
            temp = temp.next;
        }
        System.out.println(temp);
    }

4，合并两个有序链表。

两个有序的链表，将它合并为一个有序链表，合并后依然是有序的。

思绪是这样的，将两个结点进行比较，然后将小的一个结点添加到新的链表末端。

  //合并两个有序链表
    public static MyList PlusSortList(MyNode list1,MyNode list2){
        if(list1 == null || list2 == null){
            return null;
        }
       MyList list = new MyList();
        //MyNode newList = list.getHead();
        MyNode newList = new MyNode();//新链表的头结点
        //MyNode newListTemp = null;
        MyNode tem1 = list1.next;
        MyNode tem2 = list2.next;
        /*第一步首先是在头结点后面挂一个值，为什么要这样做呢？因为我之前没有
        挂值，然后直接就是开始循环，然后发现始终做不出来，后来仔细想了一下，
        我是这样认为的，如果不先挂一个，那么那个辅助指针就为null，就乱了*/
        if(tem1.Number < tem2.Number){
            newList = tem1;
            tem1 = tem1.next;
        }else{
            newList = tem2;
            tem2 = tem2.next;
        }
        MyNode temp3 = newList;
        while(true){
            if(tem1.next == null && tem2.next == null){
                break;
            } else if(tem1.next == null && tem2.next != null){
                temp3.next = tem2;
                break;
            }else if(tem2.next == null && tem1.next != null){
               temp3.next = tem1;
                break;
            }
            if(tem1.Number < tem2.Number){
                temp3 = tem1;
                tem1 = tem1.next;
                temp3 = temp3.next;
            }else {
                temp3 = tem2;
                tem2 = tem2.next;
                temp3 = temp3.next;
            }
        }
        list.Addnode(newList);
        return list;
    }

各位看完如果有问题欢迎提出来。