【数据结构与算法】六、手动实现树结构代码示例

最新推荐文章于 2024-11-09 12:43:52 发布
最新推荐文章于 2024-11-09 12:43:52 发布
阅读量223 收藏 1
点赞数 1
分类专栏： 08_数据据结构与算法专题 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43333483/article/details/125629852
版权

上一篇【数据结构与算法】五、树结构-从二叉树到B+Tree

文章目录

1、二叉树：

/**
 * 二叉树：
 *      就是单向链表中的节点中持有两个
 *      指向下一个引用的变量，且下一个
 *      引用不能去指向原有树中出现过的
 *      元素。
 *      二叉树的每个节点最多只能有两个子节点。
 *      如果有往回指向的子节点引用那么在查询时就会往回检索，
 *      那么这个数据结构就是图。
 *      增加、删除、修改的时间复杂度均为O(1)，
 *      查询的时间复杂度为O(n)，完全和链表一样
 * 
 * 二叉搜索树：
 *      在二叉树定义的基础上，附加一条对所有节点其
 *      左子树所有的节点必须小于根节点，右子树
 *      所有的节点必须大于根节点。
 *      
 *      因为其在增加删除、修改的时候都需要先查询一次应该存放的位置，
 *      所以其增加、删除、修改和查询的时间复杂度均为O(log(n))
 */
public class BinarySearchTree {
    
    /*
     * 二叉树搜索树的根节点
     */
    private BinarySearchTreeNode<Integer> root;
    
    
    
    /**
     * 递归添加节点方法
     * @param root   根节点
     * @param item      值
     * @return  添加后的根节点
     */
    private BinarySearchTreeNode<Integer> addRecursive(BinarySearchTreeNode<Integer> root, int item) {
        //如果根节点为空，创建一个节点返回
        if (root == null) {
            return new BinarySearchTreeNode<Integer>(item);
        }
        //如果要添加的节点小于根节点则放到左子树中
        if (item < root.item) {
            root.left = addRecursive(root.left, item);
        } else if (item > root.item) {//如果要添加的节点大于根节点则放到右子树中
            root.right = addRecursive(root.right, item);
        } else {
            //如果要添加的节点等于根节点则返回根节点
            return root;
        }
     
        return root;
    }
    
    /**
     * 递归查询是否包含方法
     * @param root      根节点
     * @param item  需要查询的值
     * @return      是否包含
     */
    private boolean containsNodeRecursive(BinarySearchTreeNode<Integer> root, int item) {
        //如果根节点为空直接返回false
        if (root == null) {
            return false;
        } 
        //如果要查询的值就是根节点那么直接返回true
        if (item == root.item) {
            return true;
        } 
        //递归寻找：如果当前值小于等于根则递归左边，否则递归右边
        return item <= root.item
          ? containsNodeRecursive(root.left, item)
          : containsNodeRecursive(root.right, item);
    }
    
    
    
    /**
     * 对外暴露添加节点的方法
     * @param item  需要添加的元素
     */
    public void add(int item){
        this.root = addRecursive(root, item);
    }
    
    /**
     * 对外暴露是否包含节点的方法
     * @param item
     * @return
     */
    public boolean contains(int item){
        return containsNodeRecursive(root, item);
    }
    
    /**
     * 对外提供一个删除的方法
    * @param item		要删除的元素
    * @return		返回删除是否成功
     */
    public boolean remove(int item){
    	//将根节点设置为删除后的返回值
    	root = removeRecursive(root, item);
    	return true;
    }
    
    
    /**
     * 递归删除节点方法
    * @param current		需要删除的节点
    * @param item 	要删除的元素
    * @return		被删除的节点
     */
    private BinarySearchTreeNode<Integer> removeRecursive(
    				BinarySearchTreeNode<Integer> current,int item){
    	
    	//校验入参
    	if(current == null){
    		return null;
    	}
    	
    	//如果当前节点是要删除的节点就执行删除
    	if(current.item == item){
    		/*
        	 * 那么删除节点就需要分为三种情况：
        	 * 1、要删除的节点是叶子节点（无子节点的节点）
        	 * 2、有一个子节点的非叶子节点
        	 * 3、有两个子节点的非叶子节点
        	 */
        	//如果是叶子节点那么只需将父节点的引用断掉即可
        	if(current.left == null && current.right == null){
        		//这里在上层是将父节点赋值为返回值所以直接返回null
        		return null;
        	}
        	
        	//如果左边节点为空表示子节点是右边节点，就返回右节点
        	if(current.left == null){
        		return current.right;
        	}
        	//如果右边节点为空表示子节点是左边节点，就返回左节点
        	if(current.right == null){
        		return current.left;
        	}
        	
        	/*
        	 * 如果有两个节点，那么必须先找到删除后代替
        	 * 被删除节点位置的节点然后再执行删除，
        	 * 这里我是取右子树中大于被删除节点的最小的节点
        	 */
        	Integer smallestItem = findSmallestItem(current.right);
        	//用其右子树中大于被删除节点的最小节点代替
        	current.item = smallestItem;
        	//递归删除掉右子树
        	current.right = removeRecursive(current.right, smallestItem);
        	//然后返回当前节点
        	return current;
    	}
    	//如果需要删除的值小于当前节点的值那么就递归左边
    	if(item < current.item){
    		current.left = removeRecursive(current.left, item);
    		//然后返回当前节点即返回已经被删除节点的父节点
    		return current;
    	}
    	//如果果需要删除的值大于当前节点的值那么就递归右边
    	current.right = removeRecursive(current.right, item);
    	//然后返回当前节点即返回已经被删除节点的父节点
    	return current;
    }
    
    /**
     * 找到右子树中最小的大于根节点的节点
    * @param root	根节点
    * @return	找到的结果
     */
    private <E> E  findSmallestItem(BinarySearchTreeNode<E> root){
    	/*
    	 * 这里又需要递归，如果root.left == null说明找到了
    	 * 否则就继续递归寻找左子树知道找到为止
    	 */
    	return	root.left == null ? root.item : findSmallestItem(root.left);
    }
    
    
    
    
    /**
     * 一个私有的静态内部类作为二叉树的元素
     * 这里由于后面的算法题中需要使用到这个
     * 静态内部类，所以把其写成public的，并
     * 把其成员变量也写成public的
     * @author Peter
     */
    public static class BinarySearchTreeNode<E>{
        
        /*
         * 左边的子节点
         */
        public BinarySearchTreeNode<E>  left;
        
        /*
         * 右边的子节点
         */
        public BinarySearchTreeNode<E>  right;
        
        
        public  E item;
        
        public BinarySearchTreeNode(){
            
        }
        
        public BinarySearchTreeNode(E e){
            this.item=e;
        }
        
         @Override
         public String toString() {
             if (item == null) {
                 return "null";
             }
             return item.toString();
         }
    }

	public static void main(String[] args) {
		
	    
	    

	}
	
	

    public BinarySearchTreeNode<Integer> getRoot() {
        return root;
    }


}

2、跳表结构的实现

/**
 * 跳表结构的实现
 * 为了方便不做泛型了直接用Integer
 * 
 * 跳表结构的特点：
 * 1、有多个层的数据；
 * 2、有多少层是由一个随机算法决定的；
 * 3、最底层包含整个跳表的所有元素；
 * 4、是采用空间换时间的思想实现的。
 * @author Peter
 */
public class SkipList {
    
    private  static final byte HEAD_NODE=(byte)-1;
    
    private  static final byte ELEMENT_NODE=(byte)0;
    
    private  static final byte TAIL_NODE=(byte)1;
    
    
    private Node head;
    
    private Node tail;
    
    private int size;
    
    private int height=1;
    
    private Random random;
    
    public SkipList() {
        this.head=new Node(null,HEAD_NODE);
        this.tail=new Node(null,TAIL_NODE);
        head.right=tail;
        tail.left=head;
        this.random=new Random();
    }
    
    
    
    public int size(){
        return this.size;
    }
    
    public boolean contains(Integer e){
        //首先先寻找
        Node foundNode = this.find(e);
        /*
         * 如果找到的和我们要判断是否存在的
         * 相等，那么说明集合中包含这个元素。
         */
        return foundNode.item.equals(e);
    }
    
    
    public void add(Integer e){
        //首先找到应该添加的临近的节点
        Node nearNode = this.find(e);
        //然后创建一个要添加的节点
        Node toAddNode=new Node(e);
        //将要添加的节点的左边设置为原有的附近的节点
        toAddNode.left=nearNode;
        //将要添加的节点的右边设置为原有的附近的节点的右边
        toAddNode.right=nearNode.right;
        //将原有的附近的节点的右边节点的左边设置为要添加的节点
        nearNode.right.left=toAddNode;
        //将原有的附近的节点的右边设置为要添加的节点
        nearNode.right=toAddNode;
        
        //决定该放在哪一层
        int currentLayer=1;
        //用随机数决定是否需要提高层次    1 、2 、3、4
        while(random.nextInt(4)+1>2){
            
            //如果超过原有的层高了
            if(currentLayer>=this.height){
                height++;
                Node dummyHead=new Node(null, HEAD_NODE);
                Node dummyTail=new Node(null, TAIL_NODE);
                
                dummyHead.right=dummyTail;
                dummyHead.down=head;
                head.up=dummyHead;
                
                dummyTail.left=dummyHead;
                dummyTail.down=tail;
                tail.up=dummyTail;
                
                head=dummyHead;
                tail=dummyTail;
            }
            
            //这里说明还需要往左挪位置
            while(nearNode!=null && nearNode.up==null){
                nearNode=nearNode.left;
            }
            nearNode=nearNode.up;
            
            //创建一个要添加节点的上层节点
            Node upToAddNode=new Node(e);
            //设置上层节点的链表关系
            upToAddNode.left=nearNode;
            upToAddNode.right=nearNode.right;
            upToAddNode.down=toAddNode;
            
            //设置临近节点的关系
            nearNode.right.left=upToAddNode;
            nearNode.right=upToAddNode;
            
            //设置要添加节点的关系
            toAddNode.up=upToAddNode;
            //可能循环提高层高所以
            toAddNode=upToAddNode;
            
            currentLayer++;
            
        }
        size++;
        
    }
    
    public void flushSkipList(){
        Node tempNode=head;
        //从最高层一层一层往下刷新
        for(int i=height;i>0;i--){
            System.out.print("总共："+height+"层，当前层数："+i);
            Node toFlushNode=tempNode.right;
            while(toFlushNode.type==ELEMENT_NODE){
                System.out.print("-->"+toFlushNode.item);
                toFlushNode=toFlushNode.right;
            }
            //本层打印完就换行
            System.out.println();
            tempNode=tempNode.down;
        }
        System.out.println("--------------------打印完毕-----------------------");
    }
    
    
    private Node find(Integer e){
        Node current=head;
        while(true){
            /*
             * 如果当前元素的右边节点不是末尾节点，
             * 且要添加的元素比当前节点右边的节点大，
             * 那么就进行交换，将当前节点变为
             * 当前节点的右边节点
             * 此过程为一直在同层中往右走寻找大于等于自己的元素，直到找到为止
             */
            while(current.right.type!=TAIL_NODE  && e>=current.right.item){
                current=current.right;
            }
            
            /*
             * 如果是在最底层说明不用再找了
             * 已经找到位置了直接跳出循环
             */
            if(current.down==null){
                break;
            }
            //如果不是最底层又继续往下层找
            current=current.down;
        }
        /*
         * 如果要寻找的元素存在于本集合中，那么
         * 这里可以确定要寻找的元素>=current
         * 且<=current.right
         */
        return current;
    }
    
    private  static class Node{
        
        private Integer item;
        
        private Node up,down,left,right;
        
        private byte type;
        
        public Node(Integer e){
            this(e,ELEMENT_NODE);
        }
        
        public Node(Integer e,byte type){
            this.item=e;
            this.type=type;
        }
        
    }
    
    

	public static void main(String[] args) {
		
	    SkipList mySkipList=new SkipList();
        mySkipList.add(10);
        mySkipList.flushSkipList();
//      mySkipList.add(5);
//      mySkipList.flushSkipList();
        //添加100个小于1000的随机数
        Random random=new Random();
        for(int i=0;i<100;i++){
            mySkipList.add(random.nextInt(1000));
        }
        mySkipList.flushSkipList();
	}
}

3、中序遍历递归写法

/**
 * 
 * 
 * https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
 * 中序遍历递归写法
 */
public class LeeCodeTest01 {
	
	private List<Integer> treeNodeList = new ArrayList<>();
	
	/**
	 * 递归写法
	 * @param root
	 * @return
	 */
    public List<Integer> inorderTraversal1(TreeNode root) {

        
        if(root == null){
            return treeNodeList;
        }
        
        //递归左边
        inorderTraversal1(root.left);
        treeNodeList.add(root.val);
        //递归右边
        inorderTraversal1(root.right);

        return treeNodeList;
    }
    
    
    private static class TreeNode{
    	
    	private TreeNode left;
    	
    	private TreeNode right;
    	
    	private int val;
    	
    }

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

}

4、中序遍历递归写法

/**
 * 
 * https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
 * 前序遍历递归写法
 */
public class LeeCodeTest02 {
	
	private List<Integer> treeNodeList = new ArrayList<>();
    
	/**
	 * 递归的方式
	 * @param root
	 * @return
	 */
    public List<Integer> preorderTraversal1(TreeNode root) {

        
        if(root == null){
            return treeNodeList;
        }
        
        treeNodeList.add(root.val);
        //递归左边
        preorderTraversal1(root.left);
        //递归右边
        preorderTraversal1(root.right);

        return treeNodeList;
    }
    
    
    
    private static class TreeNode{
    	
    	private TreeNode left;
    	
    	private TreeNode right;
    	
    	private int val;
    	
    }

	public static void main(String[] args) {

	}

}

5、树的各种遍历方式：

/**
 * 树的各种遍历方式：
 * 前序遍历：根 --> 左子树 --> 右子树
 * 中序遍历：左子树 --> 根 --> 右子树
 * 后序遍历：左子树 --> 右子树 --> 根
 * https://www.cnblogs.com/zhi-leaf/p/10813048.html
 */
public class TreeErgodicTest {

	public static void main(String[] args) {
		//准备数据
	    BinarySearchTree binarySearchTree = new BinarySearchTree();
        binarySearchTree.add(39);
        binarySearchTree.add(20);
        binarySearchTree.add(69);
        
        binarySearchTree.add(11);
        binarySearchTree.add(27);
        binarySearchTree.add(23);
        
        binarySearchTree.add(50);
        binarySearchTree.add(87);
//        binarySearchTree.remove(69);
        
        
//      System.out.println(binarySearchTree.contains(23));
        
        BinarySearchTreeNode<Integer> root = binarySearchTree.getRoot();
        System.out.println("根节点是："+root);
        
//        prePrint1(root);
//        prePrint2(root);
        
//        middlePrint1(root);
//        middlePrint2(root);
        
        postPrint1(root);
        postPrint2(root);
        
        
        levelPrint(root);
        

	}
	
	
	/**
	 * O(2^n)
	 * O(n)
     * 前序遍历打印二叉搜索树（递归的方式）
     * 根 --> 左子树 --> 右子树
     * @param root 二叉树的根节点
     */
    private static <E> void prePrint1(BinarySearchTreeNode<E> root){
        
        if(root == null){
            return;
        }
        
        System.out.print(root.item+"-->");
        //递归左边
        prePrint1(root.left);
        //递归右边
        prePrint1(root.right);
        
    }
    
    
    /**
     * 非递归的方式（使用栈的方式）
     * 1、弹栈并进行打印
     * 2、如果有右子节点，就将右子节点进行压栈
     * 3、如果有左子节点，就将左子节点进行压栈
     * 即：先根再右再左
     * 压完栈后执行弹栈操作，弹出时就进行打印
     * 然后重复2和3步骤
     * 
     * 时间复杂度为：O(n)
     * 空间复杂度为：O(?)
     * 前序遍历打印二叉搜索树
     * 根 --> 左子树 --> 右子树
     * @param root 二叉树的根节点
     */
    private static <E> void prePrint2(BinarySearchTreeNode<E> root){
        
        System.out.println();
        if(root == null){
            return;
        }
        //准备一个栈
        Stack<BinarySearchTreeNode<E>> stack = new Stack<>();
        //首先将根节点进行压栈
        stack.push(root);
        //如果栈不为空就一直执行
        while(!stack.isEmpty()){
            //进行弹栈，并替换掉根节点的值，弹出时就进行打印
            root = stack.pop();
            System.out.print(root.item+"-->");//invoke method
            //如果有右子节点，就将右子节点进行压栈
            if(root.right != null){
                stack.push(root.right);
            }
            //如果有左子节点，就将左子节点进行压栈
            if(root.left != null){
                stack.push(root.left);
            }
        }
        
    }
    
    
    /**
     * 中序遍历打印二叉搜索树（中序遍历是有序的）
     * 左子树 --> 根 --> 右子树
     * @param root 二叉树的根节点
     */
    private static <E> void middlePrint1(BinarySearchTreeNode<E> root){
        
        if(root == null){
            return;
        }
        
        //递归左边
        middlePrint1(root.left);
        System.out.print(root.item+"-->");
        //递归右边
        middlePrint1(root.right);
        
    }
    
    
    /**
     * 中序遍历打印二叉搜索树（中序遍历是有序的）
     * 左子树 --> 根 --> 右子树
     * 
     * 1、将树的左边界的元素全部依次压入栈中
     * 2、弹栈并进行打印，然后去弹栈元素的右子树
     * 将其右子树的左边界全部依次压入栈中，重复此过程
     * 时间复杂度：O(n)
     * 空间复杂度：O(n)
     * @param root 二叉树的根节点
     */
    private static <E> void middlePrint2(BinarySearchTreeNode<E> root){
        
        System.out.println();
        if(root == null){
            return;
        }
        //准备一个栈
        Stack<BinarySearchTreeNode<E>> stack = new Stack<>();
        
        while(!stack.isEmpty() || root != null){
            //如果根节点不为空
            if(root != null){
                //将根节点压入栈中
                stack.push(root);
                //根节点变为根节点的左子节点
                root = root.left;
                continue;
            }
          //如果根节点为空
          //根节点变为弹栈的元素
          root = stack.pop();
          //打印当前根节点
          System.out.print(root.item+"-->");
          //根节点变为根节点的右子节点
          root = root.right;
        }
    }
    
    
    /**
     * 后序遍历打印二叉搜索树
     * 左子树 --> 右子树 --> 根
     * @param root 二叉树的根节点
     */
    private static <E> void postPrint1(BinarySearchTreeNode<E> root){
        
        if(root == null){
            return;
        }
        
        //递归左边
        postPrint1(root.left);
        //递归右边
        postPrint1(root.right);
        System.out.print(root.item+"-->");
        
    }
    
    
    /**
     * 后序遍历打印二叉搜索树
     * 左子树 --> 右子树 --> 根
     * 
     *  非递归的方式（使用两个栈的方式）
     * 1、弹栈，然后将弹出元素压入另一个栈
     * 2、如果有左子节点，就将左子节点进行压栈
     * 3、如果有右子节点，就将右子节点进行压栈
     * 即：先根再左再右
     * 压完栈后执行弹栈操作，弹出后
     * 将弹出元素压入另一个栈
     * 然后重复2和3步骤
     * @param root 二叉树的根节点
     */
    private static <E> void postPrint2(BinarySearchTreeNode<E> root){
        
        System.out.println();
        
        if(root == null){
            return;
        }
        //准备两个栈
        Stack<BinarySearchTreeNode<E>> stack1 = new Stack<>();
        Stack<BinarySearchTreeNode<E>> stack2 = new Stack<>();
        //首先将根节点进行压栈
        stack1.push(root);
        //如果栈不为空就一直执行
        while(!stack1.isEmpty()){
            //进行弹栈，并替换掉根节点的值，弹出时不打印
            root = stack1.pop();
            //将弹栈的元素压入另一个栈
            stack2.push(root);
            //如果有左子节点，就将左子节点进行压栈
            if(root.left != null){
                stack1.push(root.left);
            }
            //如果有右子节点，就将右子节点进行压栈
            if(root.right != null){
                stack1.push(root.right);
            }
        }
        //等第一个栈的元素都弹栈完了，将第二个栈元素进行弹栈并打印
        while(!stack2.isEmpty()){
            System.out.print(stack2.pop().item+"-->");
        }
        
    }
    
    
    /**
     * 层次遍历打印二叉搜索树
     * 根节点那一层为第一层，第二层，第三层
     * 
     *  需要使用队列
     * 1、首先把根节点放入队列
     * 2、获取到队首元素并打印
     * 3、将其左子节点入队，将其右子节点入队
     * 4、重复2和3过程
     * @param root 二叉树的根节点
     */
    private static <E> void levelPrint(BinarySearchTreeNode<E> root){
        
        System.out.println();
        
        if(root == null){
            return;
        }
        //准备一个队列
        Queue<BinarySearchTreeNode<E>> queue = new LinkedList<>();
        //首先把根节点放入队列
        queue.offer(root);
        //如果队列不为空就一直执行
        while(!queue.isEmpty()){
            //获取到队首元素
            BinarySearchTreeNode<E> current = queue.poll();
            //出队后就打印
            System.out.print(current.item+"-->");
            //将其左子节点入队
            if(current.left != null){
                queue.offer(current.left);
            }
            //将其右子节点入队
            if(current.right != null){
                queue.offer(current.right);
            }
            //重复此过程直到没有子节点为止
        }
        
    }

}
北城小林
关注
专栏目录
【数据结构与算法】树结构(二叉树)
MiMeng的博客
01-10 326
文章目录树结构 树结构
【数据结构与算法】详解什么是树结构，并用代码手动实现一个二叉查找树
热门推荐
零一的博客
09-02 2万+
本篇文章将开始讲解树结构。其实树结构是平日里我们常见的一种数据结构，例如家族族谱、公司管理层级结构图等，这样的数据结构的存在一定有一定的道理。因此，在计算机领域中，树结构也是会被广泛用到的，例如数据库系统中就有用到。那么本文就从零开始学习一下树结构，并且也会封装一个二叉查找树，本文 3万+ 的详细教程，希望大家耐心观看，我是以一个纯小白的角度来写的这篇文章，相信大家认真看一定都能看懂的
二叉树 - 树形结构（Java语言详解）概念及具体代码实现
qq_46116963的博客
03-12 2129
二叉树-树形结构-天然的查找语义 目录 二叉树-树形结构-天然的查找语义 二叉树的主要难点 什么时候能用递归？ 如何写递归程序： 一，为何要有树结构？ 二，数据结构常用的树结构 logN 三，关于树的基础概念 概念 树与非树？ 树中需要了解的概念 其余： 四，二叉树*** 概念： 二叉树的特点: 两种特殊的二叉树 五，二叉树的性质 六，二叉树的存储方式 七，二叉树的遍历 遍历： 深度优先遍历 广度优先遍历 八，二叉树的其他基础操作 获取...
数据结构04--树（知识点+代码版）
weixin_62737397的博客
04-06 1108
一. 树的定义和基本术语一. 树的定义和基本术语。
数据结构与算法（树和二叉树及python代码实现）
sun_xiao_kai的博客
02-12 1884
树的概念 树是一种抽象数据类型(ADT)或是视作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合，他是由n（n>1）个有限节点组成一个具有层次结构的集合。把它叫做树是因为它看起来像一颗倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 每个节点有零个或多个子节点 没有父节点的节点称为根节点 每一个非根节点有且只有一个父节点 除了根节点外，每个子节点可以分为多个不相交...
数据结构与算法笔记V0.8（持续更新）
欢迎！欢迎来到17号城市！
02-27 2083
数据结构 + 算法 = 程序。无论从事前端还是后端，无论使用什么编程语言，只要想进大厂，都绕不开考核数据结构与算法。本文中的代码均用Java编写，当然，也可以使用其他语言来实现。
数据结构与算法：堆与优先队列的深入剖析
weidl001的博客
10-14 1357
堆是一棵完全二叉树，其中每个节点的值都不小于（或不大于）其子节点的值。这种特性使得堆非常适合实现优先队列，堆中的最大（或最小）元素总是位于树的根部。二叉堆与其在优先队列中的应用：二叉堆是堆的一种常见实现，通常用于实现优先队列。二叉堆可以分为最大堆和最小堆两种类型。在最大堆中，每个父节点的值大于或等于其子节点的值；在最小堆中，父节点的值小于或等于其子节点的值。代码示例：最小堆的实现*a = *b;*b = temp;printf("堆已满\n");return;size++;
《数据结构与算法分析》上的代码实现.zip
06-16
这本书的代码实现.zip文件包含了作者为讲解各种数据结构和算法所编写的C/C++/JAVA/Python语言的示例代码，旨在帮助大学生深入理解这些概念并提升编程技能。 数据结构是组织和存储数据的方式，它直接影响到算法的...
利用 Go 语言实现常用的数据结构与算法。.zip
06-17
本资源包"利用 Go 语言实现常用的数据结构与算法"提供了一种以 Go 语言为载体学习数据结构与算法的方法，尤其适合已经熟悉 C/C++/JAVA/Python 的大学生进行拓展学习。 数据结构是指在计算机中组织和存储数据的方式...
python 数据结构与算法.zip
06-16
在IT领域，数据结构与算法是编程的基础，尤其对于学习C/C++/JAVA/Python等语言的大学生来说，这是必须掌握的重要知识。"python 数据结构与算法.zip"这个压缩包很可能包含了丰富的学习资源，帮助学生深入理解数据结构...
C++数据结构代码实现.zip
10-03
这个压缩包“C++数据结构代码实现.zip”很可能包含了用C++语言实现的一些基本和高级的数据结构示例。下面我们将深入探讨其中可能包含的知识点。 1. **数组**：C++中的数组是最基础的数据结构，它允许存储相同类型的...
PHP常用算法和数据结构示例(必看篇)
10-20
在本文中，我们将深入探讨PHP中的常用算法和数据结构，并通过示例代码来解析它们的工作原理。算法和数据结构是编程中的基础概念，对于优化代码性能、提高问题解决能力至关重要。 首先，我们来看冒泡排序（Bubble ...
【数据结构】——【树】算法代码实现（C/C++语言实现）（整理不易，请多关注）
qq_51795098的博客
05-15 874
1.树的长子-兄弟表示法 #include<stdio.h> typedef int DataType ; struct CSNode; /* 树中结点结构 */ typedef struct CSNode *PCSNode; /* 结点的指针类型 */ struct CSNode { /* 结点结构定义 */ Dat...
JAVA-01-变量
LJH_laura_li的博客
11-08 419
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 261
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
基于 SpringBoot 实现QQ邮箱验证码注册功能
2301_79201049的博客
11-06 654
找到并开通以下的邮件协议服务，而且服务开启也较为简单，需要我们发送一个短信到指定的号码，开启后平台会提供一个授权码，一定要记住这个授权码，发邮件的时候需要这个。host 是根据服务主机区分，网易邮箱是 smtp.163.com, qq邮箱是 smtp.qq.com。其中的 username 是你第一步中操作的邮箱账号，nickname 是接收者收到邮件中显示的发件人。发送邮件的核心依赖是 mail ，由于该项目还涉及其他依赖就全都导进来了。（1）首先打开QQ邮箱，点击设置并来到账号页面。
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 1004
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
java_方法重写/覆盖(override)
HHppGo的博客
11-07 335
方法覆盖（重写）就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法。
并发编程的基础：深入理解内存屏障（Memory Barriers）
2401_86353562的博客
11-06 1005
内存屏障是一种基础语言，在不同的计算机架构下有不同的实现细节。本文主要在x86_64处理器下，通过Linux及其内核代码来分析和使用内存屏障对大多数应用层开发者来说，“内存屏障”（memory Barrier）是一种陌生，甚至有些诡异的技术。实际上，他机制常被用在操作系统内核中，用于实现同步、驱动程序利用它，能够实现高效的无锁数据结构，提高多线程程序的性能表现。本文首先探讨了内存屏障的必要性，之后介绍如何利用内存屏障实现一个无锁唤醒振荡器（队列），用于在多个线程间进行高效的数据交换。
大学生必备：数据结构与算法学习大全
该压缩包文件可能包含各种语言的教程、示例代码、算法题目的解决方案、练习题等，这些都是学习数据结构和算法的重要资源。通过这些资料，学习者可以加深对理论知识的理解，并在实践中不断提高解决问题的能力。 10....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值