算法－第四版－练习1.3.31解答

最新推荐文章于 2022-11-14 18:20:25 发布

photographzzz

最新推荐文章于 2022-11-14 18:20:25 发布

阅读量244

点赞数

CC 4.0 BY-SA版权

分类专栏：算法第四版

本文链接：https://blog.youkuaiyun.com/qq_26207065/article/details/81478316

算法第四版专栏收录该内容

14 篇文章

订阅专栏

本文介绍了一个使用嵌套类DoubleNode构建双向链表的方法，并实现了包括头部插入、尾部插入、头部删除、尾部删除、指定位置插入及删除等基本操作。

题目

实现一个嵌套类DoubleNode用来构造双向链表，其中每个结点都含有一个指向前驱元素的引用和一个指向后续元素的引用（如果不存在则为null）。为以下任务实现若干静态方法：在头插入结点、在表尾插入结点、从表头删除结点、从表尾删除结点、在指定结点前插入新结点、在指定结点之后插入新结点、删除指定结点。

思路

很简单。把栈和队列结合起来，然后使每个节点都指向前面的节点。

代码

package Chap1.$3;

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.Stopwatch;

public class E31
{
    private class Node
    {
        Node next;
        Node previous;
        int item;
    }

    private static Node first;
    private static Node last;
    private static int N = 0;

    public boolean isEmpty()
    {
        return N == 0;
    }
    public int size()
    {
        return N;
    }
    //从表头添加item
    public void push(int item)
    {
        Node oldfirst = first;
        first = new Node();
        first.item = item;
        if (isEmpty()) last = first;
        else
        {
            oldfirst.previous = first;
            first.next = oldfirst;
        }
        N++;
    }
    //从表头删除item
    public int pop()
    {
        int item = first.item;
        first = first.next;
        N--;
        return item;
    }
    //从表尾添加item
    public void enqueue(int item)
    {
        Node oldlast = last;
        last = new Node();
        last.item = item;
        if (isEmpty()) first = last;
        else
        {
            last.previous = oldlast;
            oldlast.next = last;
        }
        N++;
    }
    //从表尾删除item
    public int dequeue()
    {
        int item = last.item;
        last = last.previous;
        if (isEmpty()) last = null;
        N--;
        return item;
    }
    //在指定节点之前插入新节点
    public void addprevious(int n, int item)
    {
        Node node = new Node();
        node.item = item;
        if (n > this.size())
        {
            System.out.print("wrong");
            return;
        }
        Node x = first;
        for (int i = 0; i < n - 1; i++)
            x = x.next;
        node.previous = x.previous;
        x.previous.next = node;
        x.previous = node;
        node.next = x;
        N++;
    }
    //在指定节点之后插入新节点
    public void addnext(int n, int item)
    {
        Node node = new Node();
        node.item = item;
        if (n > this.size())
        {
            System.out.print("wrong");
            return;
        }
        Node x = first;
        for (int i = 0; i < n - 1; i++)
            x = x.next;
        node.next = x.next;
        x.next.previous = node;
        x.next = node;
        node.previous = x;
        N++;
    }
    //删除指定节点
    public int delete(int n)
    {
        Node x = first;
        for (int i = 0; i < n - 1; i++)
            x = x.next;
        int item = x.item;
        x.previous.next = x.next;
        x.next.previous = x.previous;
        N--;
        return item;
    }


    public static void main(String... args)
    {
        Stopwatch watch = new Stopwatch();
        E31 e = new E31();
        for (int i = 1; i < 9; i++)
        {
            e.push(i);
            e.enqueue(++i);
        }
        e.addnext(2, 7);
        e.addprevious(6, 8);
        e.delete(4);
        for (Node x = first; x != null; x = x.next)
        {
            System.out.print(x.item + " ");
        }
        System.out.println();
        System.out.println(watch.elapsedTime());
    }
}