`
zhengaihua
  • 浏览: 21537 次
  • 性别: Icon_minigender_2
  • 来自: 北京
社区版块
存档分类
最新评论

链表实现对列

    博客分类:
  • java
阅读更多
    //设置节点  
    public class LinkNode {  
        private Object obj;// 节点内数据对象  
        private LinkNode child;// 对下一个节点的引用  
        private LinkNode parent;// 对下一个节点的引用  
        public LinkNode(Object obj) {  
            this.obj = obj;  
        }  
      
        public void setObject(Object obj) {  
            this.obj = obj;  
        }  
      
        public Object getObject() {  
            return obj;  
        }  
          
        public void setChild(LinkNode child){  
            this.child =child ;  
        }  
      
        public LinkNode getChild() {  
            return child;  
        }  
        public void setParent(LinkNode parent){  
            this.parent =parent ;  
        }  
      
        public LinkNode getParent() {  
            return parent;  
        }  
    }  
    //链表实现队列  
    public class NodeQueue {  
        public static LinkNode front = null;// 第一个节点  
        public static LinkNode last = null;// 最后一个节点  
      
        /** 
         * 程序入口 
         *  
         * @param args 
         */  
        public static void main(String[] args) {  
            NodeQueue nq = new NodeQueue();  
            nq.add("aa");  
            nq.add("bb");  
            nq.add("cc");  
            nq.ModiFyLinkNode(0, "更改");  
            // nq.inserLinkNode(2, "插入");  
            nq.deleteLinkNode(2);  
            nq.printLinkNode(front);  
        }  
      
        // 添加节点  
        public void add(Object object) {  
            // 创建一个新的节点  
            LinkNode node = new LinkNode(object);  
            if (null == front) {// 如果链表为空  
                front = node;  
                last = front;  
            } else {  
                last.setChild(node);  
                node.setParent(last);  
                last = node;  
            }  
        }  
      
        // 根据索引删除元素  
        public void deleteLinkNode(int index) {  
            if (this.getLinkLenght() < index || index < 0) {  
                throw new RuntimeException("下标越界:" + index + "size:"  
                        + this.getLinkLenght());  
            } else {  
                // 得到当前索引位置的节点  
                LinkNode node = this.getLinkNode(index);  
                // 得到父节点  
                LinkNode f_node = node.getParent();  
                // 得到子节点  
                LinkNode c_node = node.getChild();  
                if (f_node == null) {  
                    front = c_node;  
                } else if (c_node == null) {  
                    f_node.setChild(null);  
                } else {  
                    f_node.setChild(c_node);  
                    c_node.setParent(f_node);  
      
                }  
            }  
        }  
      
        // 根据索引和对象名修改节点  
        public void ModiFyLinkNode(int index, Object object) {  
            if (this.getLinkLenght() < index || index < 0) {  
                throw new RuntimeException("下标越界  : " + index + "  size:  "  
                        + this.getLinkLenght());  
            }  
            LinkNode node = this.getLinkNode(index);  
            node.setObject(object);  
        }  
      
        // 获取节点对象  
        public LinkNode getLinkNode(int index) {  
            if (this.getLinkLenght() < index || index < 0) {  
                throw new RuntimeException("下标越界:" + index + "size:"  
                        + this.getLinkLenght());  
            } else {  
                int num = 0;  
                LinkNode node = front;  
                while (num != index) {  
                    node = node.getChild();  
                    num++;  
                }  
                return node;  
            }  
      
        }  
      
        // 插入节点  
        public void inserLinkNode(int index, Object object) {  
            if (this.getLinkLenght() < index || index < 0) {  
                throw new RuntimeException("下标越界" + index + "size:"  
                        + this.getLinkLenght());  
            } else {  
                // 创建新节点  
                LinkNode newnode = new LinkNode(object);  
                // 得到当前节点  
                LinkNode node = this.getLinkNode(index);  
                if (index == 0) {// 如果链表没有节点  
                    front = newnode;  
                } else if (index == this.getLinkLenght()) {// 如果为最后一个节点  
                    node.setChild(newnode);  
                    newnode.setParent(node);  
                } else {  
                    // 得到父节点  
                    LinkNode fnode = node.getParent();  
                    fnode.setChild(newnode);  
                    newnode.setChild(node);  
                }  
                // 新的引用关系  
                newnode.setParent(front);  
      
                node.setParent(newnode);  
            }  
        }  
      
        // 获取节点数,返回链表长度  
        public int getLinkLenght() {  
            int count = 0;  
            if (front == null) {  
                return count;  
            }  
            LinkNode node = front.getChild();  
            while (null != node) {  
                count++;  
                node = node.getChild();  
            }  
            return count + 1;  
        }  
      
        // 遍历链表方法  
        public void printLinkNode(LinkNode root) {  
            if (null != root) {  
                Object data = root.getObject();  
                System.out.println(data);  
                LinkNode temp = root.getChild();  
                printLinkNode(temp);  
            }  
        }  
    }  

 

分享到:
评论

相关推荐

    数组和链表实现队列

    5. **优缺点**:链表实现队列时,入队和出队操作通常较快,因为无需移动其他元素。但相比于数组,链表的随机访问性能较差,因为需要遍历找到特定位置的节点。 **对比与选择** 数组和链表实现队列各有优势,具体...

    链表实现队列

    在链表实现队列时,通常会用到两个指针:front 和 rear。front 指针指向队列的头部,也就是最早进入队列的元素;rear 指针指向队列的尾部,用于插入新元素。当进行入队操作时,我们会在队列的尾部添加一个新节点,并...

    用循环链表实现队列操作

    用循环链表实现队列操作 讲解详细 通过多次编译 可以运行的

    用链表实现队列栈 包括虚函数、指针

    在C++中,可以用数组或链表实现队列。这里使用链表作为基础,可以方便地进行插入(入队)和删除(出队)操作,而无需考虑数组的大小限制。队列的主要操作包括:enqueue(入队)、dequeue(出队)和检查队首元素。 ...

    链表-使用Python基于链表实现队列数据结构.zip

    总的来说,理解链表和如何使用链表实现队列对于深入学习数据结构和算法至关重要。通过实践和实现这些基本概念,可以更好地理解和运用它们,从而提高代码的效率和可维护性。在Python中,虽然有许多内置的工具可以方便...

    用链表实现队列(有错误).zip

    在链表实现队列时,我们需要两个主要操作:入队(enqueue)和出队(dequeue)。入队是在队尾添加元素,而出队则是从队头移除元素。 1. **入队操作**: - 创建一个新节点,包含待插入的数据。 - 如果队列为空,新...

    用链表实现队列(最终版).zip

    要使用链表实现队列,我们需要两个关键操作:入队(enqueue)和出队(dequeue)。 1. 入队操作:当一个新元素加入队列时,它被添加到队尾。在链表中,这可以通过创建一个新的节点,将新元素的值存储在节点中,然后...

    链表队列的实现

    链表队列的实现 链表队列的具体增删改查实现 是一种单链表实现

    双链表实现队列

    这是一个双链表去实现队列的列子,里面用到了指针的东西, 还有NODE的东西

    循环链表表示队列

    在循环链表表示队列中,还可以实现队列的创建操作,创建一个链队列,并将数组中的元素赋给链队列。创建操作可以通过以下步骤来实现: 1. 创建一个空链表结点,作为队列的头结点。 2. 将数组中的元素逐个插入到队列...

    Java基于双向链表实现双端队列结构(算法源码)

    * 基于双向链表实现双端队列结构 */ package dsa; public class Deque_DLNode implements Deque { protected DLNode header;//指向头节点(哨兵) protected DLNode trailer;//指向尾节点(哨兵) protected ...

    队列的链表与数组分别实现

    链表实现队列更加灵活,因为它的大小可以根据需要动态扩展。链表由一系列节点组成,每个节点包含数据和指向下一个节点的指针。链表不需要连续的内存空间,因此插入和删除操作通常比数组更快。 1. 初始化:创建两个...

    java链表应用--基于链表实现队列详解(尾指针操作)

    Java链表应用--基于链表实现队列详解(尾指针操作) Java链表应用--基于链表实现队列详解(尾指针操作)是指使用Java语言实现基于链表的队列,并且详细介绍了队列的实现细节,包括链表的改进、链表操作等。 在Java...

    用链表实现队列(头文件)

    定义了一个队列的类,包括建立队、入队、出队、打印队列、访问队首队尾的成员函数。

    数据结构的链表,队列,栈(c)

    在C语言中,可以通过数组或链表实现队列。当队列满时,可以使用循环队列避免溢出问题。 最后,栈是一种后进先出(LIFO,Last In First Out)的数据结构,类似于堆叠物品。栈的操作主要有两个:压栈(将元素放入栈顶...

    只有尾结点的链表表示的队列算法

    本篇文章将介绍一种利用链表实现队列的方法,该方法的特点在于只维护一个指向链表尾部(即队列尾部)的指针。这种方法在某些场景下可以有效地减少内存的使用量,并简化代码。 首先,定义了链表的基本单元——结点...

    go语言通过数组和链表的方式实现队列 数组和链表.pdf

    4.go语言中通过链表实现队列:使用type LinkedList struct{ e interface{} next *LinkedList /*下一个节点*/ previous *LinkedList /*上一个节点*/ size int last *LinkedList /*最后一个节点*/}定义一个LinkedList...

    c++链表队列的实现

    根据给定文件的信息,我们可以总结出以下关于C++中链表队列实现的相关知识点: ### 一、链表队列的基本概念 链表队列是一种使用链表结构来实现的队列数据结构。队列是一种先进先出(First In First Out, FIFO)的...

    链表-使用Python基于链表实现的多种队列数据结构比较.zip

    在Python中,可以使用链表实现队列,如下所示: ```python class Queue: def __init__(self): self.head = None self.tail = None def enqueue(self, data): new_node = ListNode(data) if not self.head: ...

Global site tag (gtag.js) - Google Analytics