数据结构与算法---链表

链表（Linked List）

基本介绍：

链表是有序的列表，针对有头节点的链表内存分布结构如下：

 我们会发现：
1、链表是以节点的方式来存储，链式存储
2、每个节点包括data域，next域（指向下一个节点）
3、链表的各个节点不一定是连续存放
4、链表分为带头节点的链表和没有头节点的链表

逻辑结构：

head节点：不存放具体数据，作用就是表示单链表的头。 

1、添加节点（创建）：
①先创建一个head头节点，作用就是表示单链表的头
②每添加一个节点，就直接加入到链表的最后

2、遍历单链表：
通过一个辅助数组遍历，帮助遍历整个数组

3、按照编号的顺序添加节点：
①首先找到新添加的节点位置，是通过辅助变量（指针）
②新的节点.next=tmp.next
③tmp.next=新的节点

4、单链表节点的修改
①根据节点的id来修改，不能修改节点的id
②先找到该节点，通过遍历。修改即可。

5、单链表节点的删除
①先找到需要删除节点的前一个节点tmp
②tmp.next=tmp.next.next
③被删除的节点将不会有其他引用指向，会被垃圾回收机制回收

package com.datestructures;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        PeopleNode person1 = new PeopleNode(1,"白琼","beryl");
        PeopleNode person2 = new PeopleNode(2,"小明","haha");

        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //加入
        singleLinkedList.addByOrder(person2);
        singleLinkedList.addByOrder(person1);
        singleLinkedList.addByOrder(person1);
        singleLinkedList.list();
        //测试修改节点代码
        PeopleNode newPersonNode = new PeopleNode(2,"小红","红红");
        singleLinkedList.update(newPersonNode);
        singleLinkedList.list();
        //测试删除节点
        singleLinkedList.del(1);
        singleLinkedList.list();

    }
}

//定义一个SingleLinkedList 管理英雄
class SingleLinkedList {
    //初始化一个头节点，位置不能变
    private PeopleNode head = new PeopleNode(0,"","");
    //不考虑编号顺序
    // 1、找到当前链表的最后节点
    //2、将这个节点的next 指向 新的节点
    public void add(PeopleNode peopleNode) {
        PeopleNode tmp = head;
        while (true) {
            if (tmp.next == null) {
                break;
            }
            tmp = tmp.next;
        }
        tmp.next = peopleNode;
    }

    //按照标号顺序添加节点
    public void addByOrder(PeopleNode peopleNode) {
        //tmp是位于添加节点的前一个节点，否则无法加入
        PeopleNode tmp = head;
        boolean flag = false;
        while (true) {
            if (tmp.next == null) {
                break;
            } else if (tmp.next.id > peopleNode.id) {
                break;
            } else if (tmp.next.id == peopleNode.id) {
                flag = true;
                break;
            }
            tmp = tmp.next;
        }
        if (flag) {
            System.out.println("已经存在，不能添加");
        } else{
            peopleNode.next = tmp.next;
            tmp.next = peopleNode;
        }
    }

    //修改节点的信息，根据id修改，即id编号不能改
    public void update(PeopleNode newPeopleNode) {
        //判断是否为空
        if(head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        PeopleNode tmp = head.next;
        boolean flg = false;
        while(true) {
            if (tmp == null) {
                break; //已经遍历结束
            }
            if (tmp.id == newPeopleNode.id) {
                //找到
                flg = true;
                break;
            }
            tmp = tmp.next;
        }
        if (flg) {
            tmp.name = newPeopleNode.name;
            tmp.nickName = newPeopleNode.nickName;
        } else {
            System.out.printf("找不到编号 %d 的节点\n",newPeopleNode.id);
        }
    }

    //删除节点
    public void del(int id) {
        PeopleNode tmp = head;
        boolean flg = false;
        while (true) {
            if (tmp.next == null) {
                break;
            }
            if (tmp.next.id == id) {
                flg = true; //找到了
                break;
            }
            tmp = tmp.next;
        }
        if (flg) {
            //找到可以删除
            tmp.next = tmp.next.next;
        } else {
            System.out.printf("要删除的%d节点不存在\n",id);
        }
    }

    //显示链表，遍历
    public void list() {
        PeopleNode tmp = head.next;
        //判断链表是否为空
        while(true) {
            if (tmp == null) {
                break;
            }
            //输出节点信息
            System.out.println(tmp);
            tmp = tmp.next;
        }
    }
}
//定义一个HeroNode，每个HeroNode就是一个节点
class PeopleNode {
    public int id;
    public String name;
    public String nickName;
    public PeopleNode next; //next域 存放下一个节点的信息

    public PeopleNode(int pid, String pname, String pnickname) {
        this.id = pid;
        this.name = pname;
        this.nickName = pnickname;
    }

    //重写toString方法
    public String toString() {
        return "PeopleNode{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", nickName='" + nickName + '\'' +
                '}';
    }
}

几个小Demo：

1、获取单链表中节点的个数

 public static int getLength(PeopleNode head) {
        if (head.next == null) {
            System.out.println("链表为空");
        }
        PeopleNode tmp = head.next;  //需求不统计头节点数
        int count = 0;
        while (tmp != null) {
            count++;
            tmp = tmp.next;
        }
        return count;
}

2、查找单链表中的倒数第k个节点
①遍历链表，求出链表总长度length
②从链表的第一个元素开始遍历，遍历（length-k) 个
③如果找到了返回该节点，找不到返回null
 

 public static PeopleNode findLastIndexNode(PeopleNode head, int index) {
        if (head.next == null) {
            return null; //链表为空，找不到
        }
        int length = getLength(head);
        if (index <= 0 || index > length) {
            return null;
        }
        PeopleNode tmp = head.next;
        for (int i = 0; i < length-index; i++) { //3 倒数第一个 遍历3-1=2次
            tmp = tmp.next;
        }
        return tmp;
}

3、将单链表反转
①先定义一个节点reverseHead=new PeopleNode();
②从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端 
③原来的链表的head.next = reverseNode.next

 public static void reverseList(PeopleNode head) {
        //如果当前链表为空或者只有一个节点，直接返回
        if (head.next == null || head.next.next == null) {
            return;
        }
        PeopleNode tmp = head.next;
        PeopleNode next = null;  //指向当前节点tmp的下一个节点
        PeopleNode reverseNode = new PeopleNode(0,"","");
        while (tmp != null) {
            next = tmp.next; //保存当前节点的下一个节点
            tmp.next = reverseNode.next; //将tmp的下一个节点指向链表的最前端
            reverseNode.next = tmp; //将tmp连接到新的链表上
            tmp = next; //让tmp后移
        }
        head.next = reverseNode.next;
    }

4、 从尾到头打印单链表
①反转打印
②利用栈这个数据结构，将各节点压入栈中，然后利用栈的先进后出的特点实现逆序打印。（没有改变链表的本身结构）

  public static void reversePrint(PeopleNode head) {
        if (head.next == null) {
            return;
        }
        Stack stack = new Stack<PeopleNode>();
        PeopleNode cur = head.next;
        //压栈
        while(cur != null) {
            stack.push(cur);
            cur = cur.next; 
        }
        //出栈
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

 存在问题：
1、查找的方向只能是一个方向
2、不能自我删除，需要靠辅助节点。。引入双向列表

-----------------------------------------------------------------------------------------------------------

为了解决单向链表查找的方向只能是一个方向、不能自我删除，需要靠辅助节点的问题，引入双向列表。

双向链表的遍历、添加、删除的操作

1、遍历：和单链表相同，可以向前也可以向后
2、添加：
①先找到双向链表的最后一个节点
②tmp.next = newPeopleNode
③newPeopleNode.pre = tmp
3、修改：和单链表相同
4、删除
①可以自我删除，直接找到要删除的节点，比如tmp
②tmp.pre.next = tmp.next
③tmp.next.pre = tmp.pre