java queue stack bintaryTree tree link数据结构

最新推荐文章于 2024-09-13 21:40:38 发布
最新推荐文章于 2024-09-13 21:40:38 发布
阅读量59 收藏
点赞数
文章标签： java 数据结构与算法
原文链接：http://www.cnblogs.com/bird-z/archive/2012/09/02/2667941.html
版权

LINK（带头结点和不带头结点）

功能：实现插入、删除、反转（三种思想）

class LinkNode<Type> {
    Type data;
    LinkNode<Type> next;

    public LinkNode() {
        next = null;
    }

    public LinkNode(Type data) {
        this.data = data;
        next = null;
    }
}

class LinkList<Type> {
    private LinkNode<Type> first = null;

    public LinkList() {

    }

    public void insertNode(Type data) {
        LinkNode<Type> node = new LinkNode<Type>(data);

        if (first == null) {
            first = node;
        } else {
            node.next = first;
            first = node;
        }
    }

    public void deleteNode(Type data) {
        LinkNode<Type> tmp = first;

        if (first == null)
            return;

        if (tmp.data == data)
            first = tmp.next;

        while (tmp.next != null) {
            if (tmp.next.data == data) {
                tmp.next = tmp.next.next;
                return;// error mo return
            }

            tmp = tmp.next;
        }
    }

    public void showList() {
        LinkNode<Type> tmp = first;

        while (tmp != null) {
            System.out.print(tmp.data + " ");
            tmp = tmp.next;
        }
    }

    public void reverse1() {
        LinkNode<Type> pre, cur, last;

        if (first.next == null || first == null)
            return;

        cur = first;
        pre = null;

        while (cur != null) {
            last = cur.next;

            cur.next = pre;
            pre = cur;
            cur = last;
        }

        first = pre;
    }

    public void reverse2() {
        LinkNode<Type> cur = first, last;

        if (cur == null || cur.next == null)
            return;

        while (cur.next.next != null)
            cur = cur.next;

        last = cur.next;
        cur.next = null;

        reverse2();

        last.next = cur;
        first = last;
    }

    public void reverse3() {
        LinkNode<Type> cur, last;

        cur = first;

        if (cur == null || cur.next == null)
            return;

        last = cur.next;
        first = last;

        reverse3();

        last.next = cur;
        cur.next = null;
    }
}

class HLinkList<Type> {
    LinkNode<Type> head = new LinkNode<Type>();

    HLinkList() {

    }

    public void insetNode(Type data) {
        LinkNode<Type> node = new LinkNode<Type>(data);

        node.next = head.next;
        head.next = node;
    }

    public void showList() {
        LinkNode<Type> tmp;

        tmp = head.next;

        while (tmp != null) {
            System.out.print(tmp.data + " ");
            tmp = tmp.next;
        }
    }

    public void deleteNode(Type data) {
        LinkNode<Type> tmp = head;

        while (tmp.next != null) {
            if (tmp.next.data == data) {
                tmp.next = tmp.next.next;
                return;// error no return
            }

            tmp = tmp.next;
        }
    }

    public void reverse1() {
        LinkNode<Type> pre, cur, last;

        cur = head.next;
        pre = null;

        while (cur != null) {
            last = cur.next;

            cur.next = pre;
            pre = cur;
            cur = last;
        }

        head.next = pre;
    }

    public void reverse2() {
        LinkNode<Type> cur = head.next, last;

        if (cur == null || cur.next == null)
            return;

        while (cur.next.next != null)
            cur = cur.next;

        last = cur.next;
        cur.next = null;

        reverse2();

        last.next = cur;
        head.next = last;
    }

    public void reverse3() {
        LinkNode<Type> cur, last;

        cur = head.next;

        if (cur == null || cur.next == null)
            return;

        last = cur.next;
        head.next = last;

        reverse3();

        last.next = cur;
        cur.next = null;
    }
}

public class Link {
    public static void main(String[] args) {
        // Random random = new Random(90);

        // check
        // LinkList<Integer> link = new LinkList<Integer>();
        // for (int i = 0; i < 10; i++) {
        // link.insertNode(random.nextInt() % 100);
        // }
        //
        // link.showList();
        // System.out.println();
        //
        // link.deleteNode(1);
        // link.showList();
        // System.out.println();
        //
        // link.reverse1();
        // link.showList();
        // System.out.println();

        // check
        // HLinkList<Integer> hlink = new HLinkList<Integer>();
        // for (int i = 0; i < 10; i++)
        // hlink.insetNode(random.nextInt() % 100);
        //
        // hlink.showList();
        // System.out.println();
        //
        // hlink.deleteNode(-17);
        // hlink.showList();
        // System.out.println();
        //
        // hlink.reverse3();
        // hlink.showList();
    }
}

STACK（顺序栈和链式栈）

功能：压栈，出栈

//sequence
class SeqStack<Type> {
    private Type[] data;
    private int sp;
    private int size;

    public SeqStack(Type[] data) {
        this.data = data;
        sp = 0;
        size = data.length;
    }

    public boolean isEmpty() {
        return sp == 0;
    }

    public boolean isPull() {
        return sp == size;
    }

    public Type pop() {
        if (isEmpty())
            return null;

        sp--;
        return this.data[sp];
    }

    public void push(Type data) {
        if (isPull())
            return;

        this.data[sp] = data;
        sp++;
    }
}

// link
class LinkStack<Type> {
    class LinkStackNode {
        private Type data;
        private LinkStackNode next;

        public LinkStackNode(Type data) {
            this.data = data;
            next = null;
        }

        public LinkStackNode() {
            next = null;
        }
    }

    private LinkStackNode sp = new LinkStackNode();

    public boolean isEmpty() {
        return sp.next == null;
    }

    public Type pop() {
        Type data;

        if (isEmpty())
            return null;

        data = sp.next.data;
        sp.next = sp.next.next;

        return data;
    }

    public void push(Type data) {
        LinkStackNode node = new LinkStackNode(data);

        node.next = sp.next;
        sp.next = node;
    }
}

public class Stack {
    public static void main(String[] args) {
        
    }
}

QUEUE（顺序队列与链式队列）

功能：入队，出队。

class SequenceQueue<Type> {
    Type[] data;
    int front;
    int rear;
    int size;

    public SequenceQueue(Type[] data) {
        this.data = data;
        front = 0;
        rear = 0;
        size = data.length;
    }

    private boolean isEmpty() {
        return front == rear;
    }

    private boolean isPull() {
        return (rear + 1) % size == front;
    }

    public void enQueue(Type data) {
        if (isPull())
            return;

        this.data[rear] = data;
        rear++;
        rear %= size;
    }

    public Type deQueue() {
        Type data;

        if (isEmpty())
            return null;

        data = this.data[front];
        front++;
        front %= size;

        return data;
    }
}

class LinkQueue<Type> {
    class LinkQueueNode {
        Type data;
        LinkQueueNode next;

        public LinkQueueNode(Type data) {
            this.data = data;
            next = null;
        }

        public LinkQueueNode() {
            next = null;
        }
    }

    LinkQueueNode front;
    LinkQueueNode rear;

    private boolean isEmpty() {
        return front == null;
    }

    public void enQueue(Type data) {
        LinkQueueNode node = new LinkQueueNode(data);

        if (front == null)
            front = node;
        else
            rear.next = node;
        
        rear = node;
    }

    public Type deQueue() {
        Type data;
        
        if (isEmpty())
            return null;
        
        data = front.data;
        front = front.next;
        
        return data;
    }
}

public class Queue {
    public static void main(String[] args) {

    }
}

BINARYTREE

功能：三种遍历与广度、深度遍历。
class BinTreeNode<Type> {
    Type data;
    BinTreeNode<Type> left;
    BinTreeNode<Type> right;

    public BinTreeNode() {
        left = null;
        right = null;
    }

    public BinTreeNode(Type data) {
        this.data = data;
        left = null;
        right = null;
    }
}

interface NodeHandler<Type> {
    void visit(BinTreeNode<Type> node);
}

class BinTree<Type> {
    private BinTreeNode<Type> root;

    private BinTreeNode<Type> createTree(int level) {
        BinTreeNode<Type> root = new BinTreeNode<Type>();

        if (level < 0)
            return null;

        root.left = createTree(level - 1);
        root.right = createTree(level - 1);

        return root;
    }

    private void traversePreOrder(BinTreeNode<Type> root,
            NodeHandler<Type> handle) {
        BinTreeNode<Type> left, right;

        if (root == null)
            return;

        left = root.left;
        right = root.right;

        handle.visit(root);
        traversePreOrder(left, handle);
        traversePreOrder(right, handle);
    }

    private void traverseInOrder(BinTreeNode<Type> root,
            NodeHandler<Type> handle) {
        BinTreeNode<Type> left, right;

        if (root == null)
            return;

        left = root.left;
        right = root.right;

        traversePreOrder(left, handle);
        handle.visit(root);
        traversePreOrder(right, handle);
    }

    private void traversePostOrder(BinTreeNode<Type> root,
            NodeHandler<Type> handle) {
        BinTreeNode<Type> left, right;

        if (root == null)
            return;

        left = root.left;
        right = root.right;

        traversePreOrder(left, handle);
        handle.visit(root);
        traversePreOrder(right, handle);
    }

    private void traverseStack(BinTreeNode<Type> root, NodeHandler<Type> handle) {
        LinkStack<BinTreeNode<Type>> stack = new LinkStack<BinTreeNode<Type>>();
        BinTreeNode<Type> node;

        stack.push(root);
        while ((node = stack.pop()) != null) {
            if (node.right != null)
                stack.push(node.right);
            if (node.left != null)
                stack.push(node.left);

            handle.visit(node);
        }
    }

    private void traverseQueue(BinTreeNode<Type> root, NodeHandler<Type> handle) {
        LinkQueue<BinTreeNode<Type>> queue = new LinkQueue<BinTreeNode<Type>>();
        BinTreeNode<Type> node;

        queue.enQueue(root);
        while ((node = queue.deQueue()) != null) {
            if (node.left != null)
                queue.enQueue(node.left);
            if (node.right != null)
                queue.enQueue(node.right);

            handle.visit(node);
        }
    }

    public BinTree(int level) {
        root = createTree(level);
    }

    public void PreOrder(NodeHandler<Type> handler) {
        traversePreOrder(root, handler);
    }

    public void InOrder(NodeHandler<Type> handler) {
        traverseInOrder(root, handler);
    }

    public void PostOrder(NodeHandler<Type> handler) {
        traversePostOrder(root, handler);
    }

    public void StackOrder(NodeHandler<Type> handler) {
        traverseStack(root, handler);
    }

    public void QueueOrder(NodeHandler<Type> handler) {
        traverseQueue(root, handler);
    }
}

public class BinaryTree {
    public static void main(String[] args) {
            
    }
}

 

TREE（普通树）

功能：前后两种遍历与广度深度遍历。

import java.util.Random;

class TreeNode<Type> {
    Type data;
    TreeNode<Type> child;
    TreeNode<Type> sibling;

    public TreeNode(Type data) {
        this.data = data;
        child = null;
        sibling = null;
    }

    public TreeNode() {
        child = null;
        sibling = null;
    }
}

interface NodeHandle<Type> {
    void visit(TreeNode<Type> node);
}

class Tree<Type> {
    private TreeNode<Type> root;

    Tree(int level) {
        root = createTree(level);
    }

    private TreeNode<Type> createTree(int level) {
        TreeNode<Type> root = new TreeNode<Type>();
        TreeNode<Type> child;
        Random random = new Random();
        int n = random.nextInt(3);

        if (level < 0)
            return null;

        if (n == 0 || level == 0)
            return root;

        root.child = createTree(level - 1);
        child = root.child;

        for (int i = 0; i < n - 1; i++) {
            child.sibling = createTree(level - 1);

            if (child.sibling == null)
                continue;

            child = child.sibling;
        }

        return root;
    }

    private void traversePre(TreeNode<Type> root, NodeHandle<Type> handle) {
        TreeNode<Type> node;

        if (root == null)
            return;

        handle.visit(root);

        node = root.child;
        while (node != null) {
            traversePre(node.child, handle);
            node = node.sibling;
        }
    }

    private void traversePost(TreeNode<Type> root, NodeHandle<Type> handle) {
        TreeNode<Type> node;

        if (root == null)
            return;

        node = root.child;
        while (node != null) {
            traversePost(node.child, handle);
            node = node.sibling;
        }

        handle.visit(root);
    }

    private void traverseStack(TreeNode<Type> root, NodeHandle<Type> handle) {
        LinkStack<TreeNode<Type>> stack = new LinkStack<TreeNode<Type>>();
        TreeNode<Type> node, child;

        stack.push(root);

        while ((node = stack.pop()) != null) {
            handle.visit(node);

            child = node.child;
            while (child != null) {
                stack.push(child);
                child = child.sibling;
            }
        }
    }

    private void traverseQueue(TreeNode<Type> root, NodeHandle<Type> handle) {
        LinkQueue<TreeNode<Type>> stack = new LinkQueue<TreeNode<Type>>();
        TreeNode<Type> node, child;

        stack.enQueue(root);

        while ((node = stack.deQueue()) != null) {
            handle.visit(node);

            child = node.child;
            while (child != null) {
                stack.enQueue(child);
                child = child.sibling;
            }
        }
    }

    public void preOrder(NodeHandle<Type> handle) {
        traversePre(root, handle);
    }

    public void postOrder(NodeHandle<Type> handle) {
        traversePost(root, handle);
    }

    public void stackOrder(NodeHandle<Type> handle) {
        traverseStack(root, handle);
    }

    public void queueOrder(NodeHandle<Type> handle) {
        traverseQueue(root, handle);
    }

}

public class tree {
    public static void main(String[] args) {

    }
}

转载于:https://www.cnblogs.com/bird-z/archive/2012/09/02/2667941.html

weixin_30662109
关注
Java:实现FibonacciHeap数据结构算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-29 167
Java:实现FibonacciHeap数据结构算法（附完整源码）
尚硅谷Java数据结构与java算法 全194章笔记整理
Foools的博客
08-11 2166
前言 视频地址：https://www.bilibili.com/video/BV1E4411H73v?from=search&seid=13120683720695451628 评价：整个教程的数据结构部分讲的挺好的，知识点全都覆盖了，而且每个数据结构都有代码解释，但是最后20节算法部分讲的有点乱，算法部分我决定直接刷leetcode了 数组 稀疏数组： 二维数组的省内存的保存方法，一般是n行3列，三列分别为行，列，值。 二维数组转稀疏数组： 遍历整个二维数组，查看有多少个有效数字 根据有效数字
数据结构---关于2叉树的添加问题，还有在学习过程遇到的问题
天才周的博客
06-13 405
先说一下在学习过程遇到的问题1.遇到了空指针问题，经过指点才知道是值类型和引用类型的乱用，先说一下自己理解的值类型，所谓值类型就是在栈中直接生成的不在堆中有引用，举个例子 int i =9。而引用类型，则是在内存中开辟一个空间，由堆中所申请的指向他，如Tree tree =new Tree（）；并且在这个期间还遇到一个问题就是类的初始化顺序的问题public class TreeTest { ...
c++链表数据结构格式
Fogo_XD的博客
12-05 542
二叉树与基本链表格式种类 TreeNode(基本二叉树) struct TreeNode{ int val //树节点编号 struct TreeNode *left; //左衍生节点 struct TreeNode *right; //右衍生节点 TreeNode(int x) : //二叉树链表初始化 val(x),left(NULL),right(NULL) { } }; TreeNode是基本二叉树 它的遍历和反遍历按照层遍历而来 图示二叉树序列化为
数据结构（java版）
ha_lee的博客
12-26 2987
重新学习数据结构过程中整理出来的知识框架，方便将来学习使用。代码使用java语言编写，大部分代码是自己写的，少部分代码是学习他人的思路后改写。代码的功能只经过少量测试，如有问题欢迎指出。（样例以及图示部分参考网上，具体见水印）............
Java数据结构栏目总结
警警的博客
08-27 1221
深度优先遍历和广度优先遍历是图论中两种重要的遍历算法，它们各有优缺点和适用场景。深度优先遍历适用于需要遍历所有可能路径的问题，而广度优先遍历则更适用于解决最短路径等层次化问题。在实际应用中，可以根据问题的具体需求选择合适的遍历算法。//存储顶点集合//存储图对应的邻接矩阵//表示边的数目//是否已被访问int n = 5;// System.out.println("===深度优先===");System.out.println("===广度优先===");
java数据结构和算法
12-14
### Java数据结构与算法知识点详解 #### 一、概述 在计算机科学领域，数据结构与算法是基础且核心的部分，对于任何一门编程语言而言都至关重要。本篇文章将围绕“Java数据结构与算法”这一主题展开深入探讨，不仅...
UPC-Map-master_数据结构_
09-30
树（Tree）数据结构也可能出现在项目中，特别是二叉搜索树（Binary Search Tree）或者图（Graph）结构。在地图导航中，树或图常常用来表示地理位置和它们之间的连接。 图中的节点和边是图论的基础，它们可以表示...
spring事务详细讲解-深入浅出
小电玩
09-08 520
Spring 事务是本身就是对数据库的事务的支持，没有数据库的事务 Spring 是本身无法实现事务的。Spring只提供了统一事务管理接口，具体的实现还是由各数据库自己实现。在使用 Spring 事务时，可以通过注解或编程方式将需要进行事务管理的方法和代码块标记为事务性操作，当这些操作被执行时，Spring 会负责开启时根据当前环境中设置的隔离级别，调整数据库隔离级别。
Java多线程：深入探索与详细解析
m0_63550220的博客
09-08 1506
作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线程私有内存等部分组成。每个线程都有独立的执行路径，但共享进程的资源（如内存）。：进程是系统资源分配的基本单位，它包含了一个或多个线程以及这些线程运行所需的资源。在Java中，JVM（Java虚拟机）就是一个进程，而运行在JVM上的多个线程则共享JVM的内存空间。：并发指的是多个任务在同一时间段内交替执行，而并行则指的是多个任务在同一时刻真正同时执行。
自动生成不重复的订单id
ClaireCheney的博客
09-13 137
【代码】自动生成不重复的订单id。
Java集合：Stack详解
yang_brother的博客
09-10 568
Java 中的Stack类是一个后进先出（LIFO, Last In First Out）的数据结构，它继承自Vector类。尽管Stack是一个可用的类，但它被认为是遗留的，并且在新代码中不推荐使用。通常建议使用Deque或ArrayDeque作为替代。
币安/OK现货合约量化系统APP开发
I592O929783的博客
09-08 600
后端：考虑系统需要处理大量实时数据和高频交易的特点，选择高性能的编程语言和技术框架，如Python的Django或Flask框架，Java的Spring Boot等。用户交互界面：设计直观易用的用户交互界面，包括交易界面、策略配置界面、风险管理界面等，方便用户进行交易操作、策略配置和风险管理。市场数据接入：开发市场数据接入模块，从币安等交易所或数据服务商获取实时的市场数据，包括行情数据、订单簿数据、成交数据等。前端：选择适合开发复杂界面的前端框架，如React、Vue.js等，以提供用户友好的交互界面。
基于SpringBoot的考研资讯平台设计与实现
最新发布
linzhongshu的专栏
09-13 514
对于本次的系统开发来看，它主要是把我以前所学的知识进行了一次综合的应用。经过这次毕业设计的制作它主要是把我以前所学的理论知识应用到社会实践当中。通过这一次的考研资讯平台的设计与实现它能够有效把计算机知识与实际问题相互应用，通过计算机网络技术来解决学生生活当中的实际问题，从而提高我的编程能力。虽然在这次毕业设计当中我遇到了很多的问题和困难，但是通过不断的调试和老师的帮助让我圆满的完成了这次毕业设计。
Linux服务器Java启动脚本
Jack魏
09-08 569
本文章介绍了如何在Linux服务器上执行Java并启动jar包，通常我们会使用nohup直接启动，但是还是需要手动停止然后再次启动，那如何更优雅的在服务器上启动jar包呢，让我们一起探讨一下吧。
MyBatis面试
Tony_yitao的博客
09-09 769
MyBatis面试
springboot数据库连接由localhost改成IP以后访问报错500（2024/9/7
不起眼小菜菜的博客
09-07 363
步骤很详细，直接上教程……
Java数据结构与算法解析
"这是一份关于Java数据结构和算法的Pdf高清版资料，涵盖了与Java编程相关的数据结构和算法知识。" 在计算机科学中，数据结构和算法是两个至关重要的概念，尤其是在Java这样的编程语言中。数据结构是组织、存储和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值