资讯专栏INFORMATION COLUMN

Java 数据结构实现(DataStructure)1

宋华 / 899人阅读

摘要:双向链表的实现,必须注意双向链表的和两个指针的正确指向,以及插入和删除过程中指向操作增减的有序性。定义节点,节点数据类型为,可以通过多态方式具象化为其他类型定义从头尾节点增加节点定义从头尾节点删除节点

线性表和链表

单向链表利用了类的自引用,实现了类似指针的效果。
双向链表的实现,必须注意双向链表的head和back两个指针的正确指向,以及插入和删除过程中指向操作增减的有序性。

下面几图从java面向对象的角度说明了单向双向链表的逻辑结构,类的自引用使得逻辑指向成为可能。

以下两图说明了添加删除头尾节点时执行的顺序:

  

添加头结点时先加一个临时节点,建立此临时节点和原头节点后使此临时节点为新头结点即可。
删除尾节点时先使原次头结点为新头结点,然后删除原头节点和新头结点的连接后,再删除新头结点和原头结点的连接。

尾节点的处理方法类似。
这样的删除方法能够完全释放所有的占用空间。

下面是双向链表的实现过程,包括链表类NodeList的插入删除操作。

public class TestList 
{
    public static void main(String[] Args) 
    {
        NodeList OhMyGod = new NodeList();

        Boolean b = Boolean.TRUE;
        Character c = new Character("$");
        Integer i = new Integer(34567);
        String s = "hello";

        OhMyGod.insertFromBack(b);
        OhMyGod.print();
        OhMyGod.insertFromHead(c);
        OhMyGod.print();
        OhMyGod.insertFromBack(i);
        OhMyGod.print();
        OhMyGod.insertFromHead(s);
        OhMyGod.print();
        System.out.println(OhMyGod.deleteFromBack());
        OhMyGod.print();
        System.out.println(OhMyGod.deleteFromBack());
        OhMyGod.print();
        System.out.println(OhMyGod.deleteFromBack());
        OhMyGod.print();
        System.out.println(OhMyGod.deleteFromBack());
        OhMyGod.print();
    }
}

class Node ///定义节点,节点数据类型为Object,可以通过多态方式具象化为其他类型
{
    private Node headPointer;
    private Object data;
    private Node backPointer;


    public Node(Node hp,Object o,Node bp)
    {
        headPointer = hp;
        backPointer = bp;
        data = o;
    }
    public Node()
    {
        this(null,null,null);
    }
    public Node(Object o)
    {
        this(null,o,null);
    }
    public Node(Node hp,Object o)
    {
        this(hp,o,null);
    }
    public Node(Object o,Node bp)
    {
        this(null,o,bp);
    }

    public Node getHeadPointer() {
        return headPointer;
    }
    public Object getData() {
        return data;
    }
    public Node getBackPointer() {
        return backPointer;
    }
    public void setHeadPointer(Node headPointer) {
        this.headPointer = headPointer;
    }
    public void setBackPointer(Node backPointer) {
        this.backPointer = backPointer;
    }
}

class NodeListEmptyExcption extends RuntimeException
{

    private static final long serialVersionUID = 5130245130776457112L;
    public NodeListEmptyExcption(String name)
    {
        super("NodeList:"+name+" is Empty !");
    }
}

class NodeList
{
    private String listName;
    private Node headNode;
    private Node backNode;
    public NodeList()
    {
        this("default");
    }
    public NodeList(String listName) 
    {
        this.listName = listName;
        headNode = backNode = null;
    }
    public Boolean isEmpty()
    {
        return headNode == null;
    }
    ///////////////////////定义从头尾节点增加节点
    public void insertFromHead(Object o)
    {
        if(isEmpty())
            headNode = backNode = new Node(o);
        else 
        {
            //headNode = new Node(o,headNode);
            Node tempNode = new Node(o);
            tempNode.setBackPointer(headNode);
            headNode.setHeadPointer(tempNode);
            headNode = tempNode;


        }
    }
    public void insertFromBack(Object o)
    {
        if(isEmpty())
            headNode = backNode = new Node(o);
        else
        {
            Node tempNode = new Node(o);
            backNode.setBackPointer(tempNode);
            tempNode.setHeadPointer(backNode);
            backNode = tempNode;
        }
    }
    //////////////////////////定义从头尾节点删除节点
    public Object deleteFromHead() throws NodeListEmptyExcption
    {
        if(isEmpty())
            throw new NodeListEmptyExcption(listName);

        Object removedata = headNode.getData();

        if(headNode.equals(backNode))
        {
            headNode = backNode = null;
        }

        else 
        {
            headNode = headNode.getBackPointer();
            headNode.getHeadPointer().setBackPointer(null);
            headNode.setHeadPointer(null);  
        }
        return removedata;
    }
    public Object deleteFromBack() throws NodeListEmptyExcption
    {
        if(isEmpty())
            throw new NodeListEmptyExcption(listName);

        Object removedata = backNode.getData();
        if(headNode.equals(backNode))
        {
            headNode = backNode = null;
        }
        else 
        {
            backNode = backNode.getHeadPointer();
            backNode.getBackPointer().setHeadPointer(null);
            backNode.setBackPointer(null);
        }   
        return removedata;
    }
    public void print()
    {
        if(isEmpty())
        {
            System.out.println("Node List "+listName+" is empty !");
        return;
        }
        Node currentNode = headNode;
        while(currentNode!=null)
        {
            System.out.print(currentNode.getData().toString()+" ");
            currentNode  = currentNode.getBackPointer();
        }
        System.out.println("
");
    }
}

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/64206.html

相关文章

  • Java™ 教程(嵌套类)

    嵌套类 Java编程语言允许你在另一个类中定义类,这样的类称为嵌套类,如下所示: class OuterClass { ... class NestedClass { ... } } 术语:嵌套类分为两类:静态和非静态,声明为static的嵌套类称为静态嵌套类,非静态嵌套类称为内部类。 class OuterClass { ... stati...

    Cheng_Gang 评论0 收藏0
  • Java 数据结构实现DataStructure)2

    摘要:堆栈可以看成是有特定规则为的线性表,特定规则就是先进后出,后进先出,可以看成是我们的先的要后,所以利用这一点可以通过继承或组合的方式来构建堆栈。鉴于上面这张物理结构和逻辑结构,我们采用提供的来构建主存储结构,即节点的线性表以达到索引的目的。 堆栈 可以看成是有特定规则为的线性表,特定规则就是先进后出,后进先出,可以看成是我们List的先insertFromHead的要后deleteF...

    simpleapples 评论0 收藏0
  • 数据结构-栈

    摘要:栈也称为后进先出表栈的应用场景操作撤销例如将操作的每组数据存入栈中,如果想要撤销,只需要弹出栈顶元素,就可以恢复上一步操作了。最后执行完成,根据栈的结构开始弹出数据,一步一步再走回方法。 数据结构-栈 定义 栈(英语:stack)又称为堆栈或堆叠,栈作为一种数据结构,它按照先进后出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据(最后一个数据...

    TalkingData 评论0 收藏0
  • 数据结构-数组

    摘要:数据结构数组数组数据结构中最基本的一个结构就是线性结构,而线性结构又分为连续存储结构和离散存储结构。比如容量,扩容个,没有意义,很快就满了容量,扩充个,太多了,容易早证浪费。 数据结构-数组 数组 数据结构中最基本的一个结构就是线性结构,而线性结构又分为连续存储结构和离散存储结构。所谓的连续存储结构其实就是数组。 优点:插入块如果知道坐标可以快速去地存取 缺点:查找慢,删除慢,大...

    894974231 评论0 收藏0
  • HashedWheelTimer算法详解

    摘要:算法序和年的论文提出了一种定时轮的方式来管理和维护大量的调度算法内核中的定时器采用的就是这个方案。使用实例每一次的时间间隔每一次就会到达下一个槽位轮中的数源码解读之时间轮算法实现定时轮算法细说延时任务的处理定时器的实现 HashedWheelTimer算法 序 George Varghese 和 Tony Lauck 1996 年的论文:Hashed and Hierarchical ...

    aervon 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<