java链表实现

单向链表

/**
 * 单链表
 */
public class SingleLinkQueueDemo {

    public static void main(String[] args) {
        SingleLinkQueue queue = new SingleLinkQueue();
        AllianceNode node1 = new AllianceNode(1, "压缩");
        AllianceNode node2 = new AllianceNode(2, "永恩");
        AllianceNode node6 = new AllianceNode(6, "刀妹");
        AllianceNode node3 = new AllianceNode(3, "老鼠");
        queue.add(node1);
        queue.add(node2);
        queue.show();
        System.out.println("执行insert测试：");
        queue.insert(node6);
        queue.insert(node3);
        queue.show();
        System.out.println("执行update测试：");
        AllianceNode node61 = new AllianceNode(6, "刀妹厉害");
        queue.update(node61);
        queue.show();
        System.out.println("执行delete测试：");
        queue.delete(2);
        queue.show();
        System.out.println("执行队列反转测试：");
        queue.reverseShow(queue.getHead());
        queue.show();


    }
}

    /**
     * 定义节点类
     */
     class AllianceNode{
        public int id;
        public String name;
        public AllianceNode next;  // 指向下一个节点的指针

       public AllianceNode(int id,String name){
            this.id = id;
            this.name = name;
        }


        @Override
        public String toString() {
            return "AllianceNode{" +
                    "id=" + id +
                    ", name='" + name +
                    '}';
        }
    }

    class SingleLinkQueue{
        // 定义头节点
       private AllianceNode head= new AllianceNode(0,"");

        public AllianceNode getHead() {
            return head;
        }

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

        // 添加链表数据
        public void add(AllianceNode node){
            // 定义一个临时变量temp,使其指向链表尾部，然后将node放入next
            AllianceNode temp = head;
            while (true){
                if (temp.next==null){
                    temp.next = node;
                    break;
                }
                temp = temp.next;
            }
        }
        public void show(){
            if (head.next==null){
                System.out.println("链表为空");
                return;
            }
            AllianceNode temp = head.next;
            while (true){
                if (temp==null){
                    break;
                }
                System.out.println(temp);
                temp = temp.next;
            }
        }
        // 插入
        public void insert(AllianceNode allianceNode){
            AllianceNode node = head;
           while (true){
               if (node.next==null){
                   node.next = allianceNode;
                   break;
               }
               if (node.next.id>allianceNode.id){
                   allianceNode.next= node.next;
                   node.next=allianceNode;
                   break;
               }
               if (node.next.id==allianceNode.id){
                   System.out.println("id已存在");
                   break;
               }
               node =node.next;
           }
        }

        // 修改
        public void update(AllianceNode allianceNode){
            AllianceNode temp = head;
            while (true){
                if (temp==null){
                    break;
                }
                if (allianceNode.id==temp.id){
                    temp.name = allianceNode.name;;
                }
                temp = temp.next;
            }
        }
        // 删除
        public void delete(int id){
            AllianceNode temp= head;
            while (true){
                if (temp.next==null){
                    System.out.println("未找到元素");
                    break;
                }
                if (id==temp.next.id){
                    temp.next = temp.next.next;
                    break;
                }
                temp =temp.next;
            }
        }

        /**
         * 思路：每遍历一个节点，就将其取出，并放在新列表的head的最前端，将原来的列表放入这个新节点的next域中
         * @param node
         */
        // 队列反转
        public void reverseShow(AllianceNode node){

            if (node.next==null || node.next.next==null){
                return;
            }

            AllianceNode cur = node.next;
            AllianceNode nextValue = null;
            AllianceNode head = new AllianceNode(0,"");

            while (cur!=null){
                nextValue = cur.next;   // 指针后移
                cur.next = head.next;   // 将head尾部所有节点放到cur的下一个节点中
                head.next = cur;        // 将cur放入head的头节点的末尾
                cur = nextValue;        // 将cur指针后移
            }
            node.next = head.next;      // 将反转队列返回到原队列中

        }

    }

双向链表

思路分析：

• 1、双向列表遍历和单向列表一样，只是双向列表可以向前遍历
• 2、双向列表末尾新增
  temp.next = newNode;
  newNode.pre=temp;
• 3、双向列表的修改：和单列表一样，找到后修改
• 4、删除，因为是双向列表，可以实现自我删除，不需要向单列表一样需要找到他的前一个元素,temp 被删除元素
  temp.next.pre = temp.pre;
  temp.pre.next = temp.next;

public class DoubleLinkQueueDemo {

    public static void main(String[] args) {
        DoubleLinkQueue queue = new DoubleLinkQueue();
        AllianceNode2 node1 = new AllianceNode2(1, "压缩");
        AllianceNode2 node2 = new AllianceNode2(2, "永恩");
        AllianceNode2 node6 = new AllianceNode2(6, "刀妹");
        AllianceNode2 node3 = new AllianceNode2(3, "老鼠");
        queue.add(node1);
        queue.add(node2);
        queue.show();
        System.out.println("执行insert测试：");
        queue.insert(node6);
        queue.insert(node3);
        queue.show();
        System.out.println("执行update测试：");
        AllianceNode2 node61 = new AllianceNode2(6, "刀妹厉害");
        queue.update(node61);
        queue.show();
        System.out.println("执行delete测试：");
        queue.delete(2);
        queue.show();


    }
}

/**
 * 定义节点类
 */
class AllianceNode2{
    public int id;
    public String name;
    public AllianceNode2 next;  // 指向下一个节点的指针
    public AllianceNode2 pre;  // 指向上一个节点的指针

    public AllianceNode2(int id,String name){
        this.id = id;
        this.name = name;
    }


    @Override
    public String toString() {
        return "AllianceNode2{" +
                "id=" + id +
                ", name='" + name +
                '}';
    }
}

class DoubleLinkQueue{
    // 定义头节点
    private AllianceNode2 head= new AllianceNode2(0,"");

    public AllianceNode2 getHead() {
        return head;
    }

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

    // 添加链表数据
    public void add(AllianceNode2 node){
        // 定义一个临时变量temp,使其指向链表尾部，然后将node放入next
        AllianceNode2 temp = head;
        while (true){
            if (temp.next==null){
                temp.next = node;
                node.pre = temp;
                break;
            }
            temp = temp.next;
        }
    }
    public void show(){
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
        AllianceNode2 temp = head.next;
        while (true){
            if (temp==null){
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
    // 插入
    public void insert(AllianceNode2 AllianceNode2){
        AllianceNode2 node = head;
        while (true){
            if (node.next==null){
                node.next = AllianceNode2;
                AllianceNode2.pre = node;
                break;
            }
            if (node.next.id>AllianceNode2.id){
                AllianceNode2.next= node.next;
                AllianceNode2.pre = node;
                node.next.pre=AllianceNode2;    
                node.next=AllianceNode2;
                break;
            }
            if (node.next.id==AllianceNode2.id){
                System.out.println("id已存在");
                break;
            }
            node =node.next;
        }
    }

    // 修改
    public void update(AllianceNode2 AllianceNode2){
        AllianceNode2 temp = head;
        while (true){
            if (temp==null){
                break;
            }
            if (AllianceNode2.id==temp.id){
                temp.name = AllianceNode2.name;;
            }
            temp = temp.next;
        }
    }
    // 删除
    public void delete(int id){
        AllianceNode2 temp= head.next;
        while (true){
            if (temp==null){
                System.out.println("未找到元素");
                break;
            }
            if (id==temp.id){
                temp.pre.next = temp.next;
                if (temp.next!=null){
                    temp.next.pre = temp.pre;
                }
                break;
            }
            temp =temp.next;
        }
    }



}