【典型习题整理】数据结构与算法作业

最新推荐文章于 2020-03-01 13:42:14 发布
最新推荐文章于 2020-03-01 13:42:14 发布
阅读量125 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构与算法 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/findover/article/details/103122719
版权

数据结构与算法


Binary Search Tree

概念

       二叉搜索树
       由于其左子树总是小于当前节点key值又小于右子树，所以这种数据结构在搜索中经常用到。
       但值得注意的是，这种树如果分布地很均衡的话搜索的时间复杂度为O(log2n)，但如果输入的数据流恰好为顺序表的话，这棵树的搜索时间复杂度和链表一样O(n)。

代码实现：

package ElevenWeek;

import java.util.*;

public class BSTNode {//Binary Search Node class

	private class Node{//子类
		
		public Node left;
		public Node right;
		public int key;

		public Node(int x){this.key=x;}
	}
	
	public Node root;
	public int size;
	
	public BSTNode(){
		this.root=null;
		this.size=0;
	}
	
	public boolean isEmpty(){ return size==0;}
	
	public void add(int x){ root=add(root, x);}
	private Node add(Node node, int x){
		if(node==null){
			size++;
			return new Node(x);
		}
		
		if(node.key > x) node.left=add(node.left, x);
		else if(node.key < x) node.right=add(node.right, x);
		
		return node;
	}
	
	public boolean contains(int x){ return contains(root, x);}
	private boolean contains(Node node, int x){
		
		if(node==null) return false;
		if(node.key==x) return true;
		else if(node.key>x) return contains(node.left, x);
		else return contains(node.right, x);
	}
	
	private void visit(Node node){System.out.print(node.key+", ");}
	/**
	* 以下为先序遍历，中序遍历，后序遍历，层序遍历的非递归实现
	*
	* 其中Stack类我在前期中有写过
	*/
	public void preTravel() throws Exception{ preTravel(root);}
	private void preTravel(Node node) throws Exception{
		if(node==null) return;
		
		Stack s=new Stack(20);
		s.push(node);
		Node temp;
		
		while(!s.isEmpty()){
			temp=(Node) s.pop();
			visit(temp);
			if(temp.right!=null) s.push(temp.right);
			if(temp.left!=null) s.push(temp.left);
		}
		System.out.println();
	}
	
	public void midTravel() throws Exception{ midTravel(root);}
	private void midTravel(Node node) throws Exception{
		if(node==null) return;
		
		Stack s=new Stack(20);
		
		while(true){
			while(node!=null){
				s.push(node);
				node=node.left;
			}
			if(s.isEmpty()) break;
			node=(Node) s.pop();
			visit(node);
			node=node.right;
		}
		System.out.println();
	}
	
	public void bacTravel() throws Exception{ bacTravel(root);}
	private void bacTravel(Node node) throws Exception {
		if(node==null) return;
		
		Node curnode=node;
		Node prenode=null;
		Stack s=new Stack(20);
		
		while(curnode!=null){
			s.push(curnode);
			curnode=curnode.left;
		}
		
		while(!s.isEmpty()){
			curnode=(Node) s.pop();
			if(curnode.right==null||curnode.right==prenode){
				visit(curnode);
				prenode=curnode;
				continue;
			}
			s.push(curnode);
			curnode=curnode.right;
			while(curnode!=null){
				s.push(curnode);
				curnode=curnode.left;
			}
		}
		System.out.println();
	}
	
	public void levTravel(){ levTravel(root);}
	private void levTravel(Node node){
		if(node==null) return;
		
		Queue<Node> q=new LinkedList<Node>();
		q.offer(node);
		
		while(!q.isEmpty()){
			node=q.poll();
			visit(node);
			
			if(node.left!=null) q.offer(node.left);
			if(node.right!=null) q.offer(node.right);
		}
		System.out.println();
	}
	
	public int getMin() throws Exception{
		if(size==0) throw new Exception("BST is empty.");
		return getMin(root).key;
	}
	private Node getMin(Node node){
		while(node.left!=null){
			node=node.left;
		}
		return node;
	}
	
	public int getMax() throws Exception{
		if(size==0) throw new Exception("BST is empty.");
		return getMax(root).key;
	}
	private Node getMax(Node node){
		while(node.right!=null) node=node.right;
		return node;
	}
	
	public int delMin() throws Exception{
		int min=getMin();
		root=delMin(root);
		return min;
	}
	private Node delMin(Node node){
		if(node.left==null) return null;
		while(node.left.left!=null) node=node.left;
		node.left=null;
		return node;
	}
	
	public int delMax() throws Exception{
		int max=getMax();
		root=delMax(root);
		return max;
	}
	private Node delMax(Node node){
		if(node.right==null) return null;
		while(node.right.right!=null) node=node.right;
		node.right=null;
		return node;
	}
	
	public void remove(int x){ root=remove(root, x);}
	private Node remove(Node node, int x){
		if(node==null) return null;
		
		if(node.key>x){
			node.left=remove(node.left, x);
			return node;
		}
		else if(node.key<x){
			node.right=remove(node.right, x);
			return node;
		}
		else{
			if(node.left==null){
				Node temp=node.right;
				node.right=null;
				size--;
				return temp;
			}
			if(node.right==null){
				Node temp=node.left;
				node.left=null;
				size--;
				return temp;
			}
			// 待删除节点左右子树均不为空的情况
			// 查找待删除节点的后继节点
			// 用后继节点替换当前待删除节点
			Node prenode=getMin(node.right);
			prenode.right=delMin(node.right);
			prenode.left=node.left;
			node.left=null;
			node.right=null;
			return prenode;
		}
	}
	
	public String toString(){
		String res="";
		generateString(root, 0, res);
		return res;
	}
	
	private void generateString(Node node, int depth, String res){
		if(node==null){
			res+=generate_nbsp(depth)+"null\n";
			return;
		}
		
		res+=generate_nbsp(depth)+node.key+"\n";
		generateString(node.left, depth+1, res);
		generateString(node.right, depth+1, res);
	}
	private String generate_nbsp(int depth){
		String res="";
		for(int i=0;i<depth;i++)
			res+="--";
		return res;
	}
}

Test:

package ElevenWeek;

public class BSTree_Test {
	
	public static void main(String args[]) throws Exception{
		int[] nums={5,3,6,4,8,2};
		BSTNode bs=new BSTNode();
		for(int i=0;i<nums.length;i++)
			bs.add(nums[i]);
		
		System.out.println("pre in the first time: ");
		bs.preTravel();
		System.out.println("mid");
		bs.midTravel();
		System.out.println("bac");
		bs.bacTravel();
		System.out.println();
		
		bs.remove(bs.getMax());
		System.out.println("pre");
		bs.preTravel();
		System.out.println("mid");
		bs.midTravel();
		System.out.println("bac");
		bs.bacTravel();
		System.out.println();
		
		bs.add(8);
		bs.remove(3);
		System.out.println("pre");
		bs.preTravel();
		System.out.println("mid");
		bs.midTravel();
		System.out.println("bac");
		bs.bacTravel();
		System.out.println();
	}
}

结果：

pre in the first time:
5, 3, 2, 4, 6, 8,
mid
2, 3, 4, 5, 6, 8,
bac
2, 4, 3, 8, 6, 5,

pre
5, 3, 2, 4, 6,
mid
2, 3, 4, 5, 6,
bac
2, 4, 3, 6, 5,

pre
5, 4, 2, 6, 8,
mid
2, 4, 5, 6, 8,
bac
2, 4, 8, 6, 5,

AVT Tree

概念：

       平衡二叉树
       考虑到Binary Search Tree对于输入数据顺序的高度依赖，AVL Tree用于自动平衡二叉树，以确保每次搜索的时间复杂度总为O(log2n)。

代码实现：

package ElevenWeek;

import java.util.*;

public class AVLNode {

private class Node{
		
		public int key;
		public Node left;
		public Node right;
		public int height;
		
		public Node(int x, Node left, Node right){
			this.key=x;
			this.left=left;
			this.right=right;
		}
		
		public Node(int x){
			this.key=x;
			this.left=null;
			this.right=null;
		}
	}
	
	private static final int allow_balance=1;
	private Node root=null;
	public AVLNode(){root=null;}
	
	public boolean isEmpty(){return root==null;}
	
	public void insert(int x){root=insert(root, x);}
	
	private Node insert(Node node, int x) {
		// TODO Auto-generated method stub
		if(node==null) return new Node(x);
		if(x > node.key) node.right=insert(node.right, x);
		else if(x < node.key) node.left=insert(node.left, x);
		return balance(node);
	}
	
	private Node balance(Node node){
		if(node==null) return node;
		if(height(node.left) - height(node.right) > allow_balance){
			if(height(node.left.left) >= height(node.left.right)) node = rotate_with_left(node);
			else node = double_with_left(node);
		}
		else if(height(node.right) - height(node.left) > allow_balance){
			if(height(node.right.right) >= height(node.right.left)) node=rotate_with_right(node);
			else node=double_with_right(node);
		}
		node.height=Math.max(height(node.left), height(node.right))+1;
		return node;
	}

	private int height(Node node){return (node==null) ? 0 : Math.max(height(node.left), height(node.right))+1;}

	private Node rotate_with_left(Node node) {
		Node tempnode=node.left;
		node.left=tempnode.right;
		tempnode.right=node;
		node.height=Math.max(height(node.left), height(node.right))+1;
		tempnode.height=Math.max(height(tempnode.left), height(tempnode.right))+1;
		return tempnode;
	}
	
	private Node rotate_with_right(Node node){
		Node tempnode=node.right;
		node.right=tempnode.left;
		tempnode.left=node;
		node.height=Math.max(height(node.left), height(node.right))+1;
		tempnode.height=Math.max(height(tempnode.left), height(tempnode.right))+1;
		return tempnode;
	}
	
	private Node double_with_left(Node node){
		node.left=rotate_with_right(node.left);
		return rotate_with_left(node);
	}
	
	private Node double_with_right(Node node){
		node.right=rotate_with_left(node.right);
		return rotate_with_right(node);
	}
	
	public void remove(int x){root=remove(root, x);}
	
	private Node remove(Node node, int x){
		if(node==null) return node;
		if(x < node.key) node.left=remove(node.left, x);
		else if(x > node.key) node.right=remove(node.right, x);
		else if(node.left!=null&&node.right!=null){
			node.key=findmin(node.right).key;
			node.right=remove(node.right, node.key);
		}
		else node = (node.left==null) ? node.right : node.left;
		return balance(node);
	}
	
	public Node findmin(Node node){
		if(node==null) return null;
		if(node.left==null) return node;
		return findmin(node.left);
	}
	
	public void levTravel(){
		Queue<Node> q=new LinkedList<Node>();
		q.offer(root);
		Node temp;
		
		while(!q.isEmpty()){
			temp=q.poll();
			visit(temp);
			if(temp.left!=null) q.offer(temp.left);
			if(temp.right!=null) q.offer(temp.right);
		}
		System.out.println();
	}
	
	public void preTravel() throws Exception{ preTravel(root);}
	private void preTravel(Node node) throws Exception{
		if(node==null) return;
		
		Stack s=new Stack(20);
		s.push(node);
		while(!s.isEmpty()){
			node=(Node) s.pop();
			visit(node);
			if(node.right!=null) s.push(node.right);
			if(node.left!=null) s.push(node.left);
		}
		System.out.println();
	}
	
	public void midTravel() throws Exception{ midTravel(root);}
	private void midTravel(Node node) throws Exception{
		if(node==null) return;
		
		Stack s=new Stack(20);
		while(true){
			while(node!=null){
				s.push(node);
				node=node.left;
			}
			if(s.isEmpty()) break;
			node=(Node) s.pop();
			visit(node);
			node=node.right;
		}
		System.out.println();
	}
	
	public void bacTravel() throws Exception{ bacTravel(root);}
	private void bacTravel(Node node) throws Exception {
		if(node==null) return;
		
		Stack s=new Stack(20);
		Node curnode=node;
		Node prenode=null;
		
		while(curnode!=null){
			s.push(curnode);
			curnode=curnode.left;
		}
		while(!s.isEmpty()){
			curnode=(Node) s.pop();
			if(curnode.right==null||curnode.right==prenode){
				visit(curnode);
				prenode=curnode;
				continue;
			}
			s.push(curnode);
			curnode=curnode.right;
			while(curnode!=null){
				s.push(curnode);
				curnode=curnode.left;
			}
		}
		System.out.println();
	}

	private void visit(Node temp) {
		// TODO Auto-generated method stub
		System.out.print(temp.key+", ");
	}
}

Test

package ElevenWeek;

public class AVLNode_Test {
	
	public static void main(String args[]) throws Exception{
		
		AVLNode as=new AVLNode();
		as.insert(1);
		as.insert(2);
		as.insert(3);
		as.insert(4);
		as.insert(5);
		as.insert(6);
		as.insert(7);
		as.insert(8);
		as.insert(9);
		System.out.println("pre in the first time: ");
		as.preTravel();
		System.out.println("mid");
		as.midTravel();
		System.out.println("bac");
		as.bacTravel();
		System.out.println();
	}
}

结果如下：

pre in the first time:
4, 2, 1, 3, 6, 5, 8, 7, 9,
mid
1, 2, 3, 4, 5, 6, 7, 8, 9,
bac
1, 3, 2, 5, 7, 9, 8, 6, 4,

findover
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2018年北京邮电大学数据结构与算法第一次作业 问题D
ytzj2017的博客
03-15 1448
Problem D： 因为题目要求时间复杂度为O（n），那么遍历比较的笨办法就不能用了。 考虑到空间复杂度为O（1），设计算法时应当从数的运算本身着手，而不能使用“空间换时间”的策略。 看题目要求： 给定非空的int类型数组，数组中的元素只有一个出现一次，其余都出现两次，找出这个唯一元素。 那么，联想到异或运算的特点：a^a=0、a^0=a 于是办法有了，将所有的数统统异或...
数据结构与算法（ｅｄｕｃｏｄｅｒ作业）
m0_51622088的博客
05-16 3618
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、栈二、使用步骤1.引入库栈——实验及提升训练 前言 数据结构与算法（Ｃ语言）头歌平台 一、栈 顺序表 关卡一　第1关 求顺序线性表中连续子表（最少有一个元素）的最大和 #include <stdio.h> #include <stdlib.h> /*此处是顺序线性表数据结构定义*/ typedef int DataType; struct seqList {//有3个数据成员 int MAX.
数据结构与算法——作业2
AliceRainly的博客
02-19 195
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array 著作权归领扣网络所有。商业转载请...
数据结构与算法经典例题
Java进阶（一刀999）
02-04 1626
数据结构与算法经典 1、约瑟夫环 问题描述： 假设有n个人站成一圈，每个人都有不同的编号i（1<=i<=n），从编号为1的人开始顺时针方向“1,2,3,4….m”循 环报数，数到m的人出列。然后从出列者的下一个人重新开始按报数，数到m的人再出列，如此重复进行，直 到n个人都出列为止。对于任意给定的n个人原始排列顺序和m值，输出n个人的出列顺序。 解题思路： 1、现在假设参与人数为：n=...
PTA习题：数据结构与算法题目集1
08-08
数据结构与算法是计算机科学的基础，它涉及到如何高效地存储和处理数据，以及设计和分析解决问题的方法。在这些题目中，我们将探讨三个不同主题：...因此，不断练习和学习数据结构与算法，对于提升IT专业技能非常有益。
数据结构与算法练习题.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构和算法练习题.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
C语言数据结构算法 作业系统
03-10
◆1.16② 试写一算法，如果三个整数X，Y和Z 的值不是依次非递增的，则通过交换，令其为 非递增。 1.17③ 已知k阶裴波那契序列的定义为 f0=0, f1=0, ..., fk-2=0, fk-1=1; fn=fn-1+fn-2+...+fn-k, n=k,k+1,... 试编写求k阶裴波那契序列的第m项值的函数算法， k和m均以值调用的形式在函数参数表中出现。 1.18③ 假设有A、B、C、D、E五个高等院校进行田径对抗赛， 各院校的单项成绩均以存入计算机并构成一张表，表中每一 行的形式为 项目名称 性别 校名 成绩 得分 编写算法，处理上述表格，以统计各院校的男、女总分和团 体总分，并输出。
算法与数据结构课后与习题解析
07-22
在这个PDF文档中，读者可以找到详尽的理论解释以及一系列的练习题，以帮助深化对算法和数据结构的理解。 一、算法基础 算法是一系列解决问题的明确指令，它描述了如何执行特定任务。在计算机科学中，算法的重要性...
数据结构与算法（作业六）
BryceFei的博客
03-01 278
买股票的最佳时机 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 注意你不能在买入股票前卖出股票。 运算代码如下： class Solution { public: int maxProfit(vector<int>& prices) { if (...
【动态规划】 生产车间的零件问题
findover的博客
10-24 1521
数据结构与算法 车间问题01 题目类型描述： 生产线上有两台完全一样的机器需要处理一批零件，每一个零件一旦开始处理就不能停止，求处理完这批零件的最短时间。 输入： 第一行是一个整数n，表示零件的个数，第二行是n个整数，表示每个零件的处理时间。 输出： 处理完这批零件的最短时间。 具象理解： 假设现有5个零件，机器生产这五个零件用时各为：2，2，3，4，5（单位：min），则有如下方案： &nbs...
【动态规划】最大上限问题
findover的博客
10-04 580
数据结构与算法 题目类型描述： 给定一组物品，每种物品都有自己的重量，在限定的背包容纳量面前，我们如何选择，才能使得包内物品总重最大。 具象理解：        我们假设背包总容纳量top_weight=10，先有四个重量各为3，4，8，5的物品，计算机该如何选择？ 贪心算法：     &nbsp...
【字典查找问题】 检索
findover的博客
10-26 502
数据结构与算法 字典查找 题目类型描述： 给定一个字典和一个字符串，如何确定该字符串是由字典中的内容拼接而成？ 具象理解：        现有一个字典{“let”， “me”}和字符串“letme”，应该返回true。 抽象建模：        可以构建一个一维Boolean类...
【动态规划】 背包问题整理
findover的博客
09-30 486
【动态规划】 背包问题整理 背包问题03 题目类型描述： 给定一组物品，每种物品都有自己的重量和价格，在限定的总重量内，我们如何选择（每种物品数量不限），才能使得物品的总价格最高（from 百度百科）。 具象理解： 假设背包总容量top_weight为10，现共有四样物品（每样物品数目不限），他们的重量和价格分别为： 抽象建模：      &n...
【DFS深度优先遍历】 字母表问题
findover的博客
10-09 438
数据结构与算法 题目类型描述： 给出一个二维的字母板和一个单词，寻找字母板网格中是否存在这个单词（单词可以由按顺序的相邻单元的字母组成，其中相邻单元指的是水平或者垂直方向相邻。每个单元中的字母最多只能使用一次）。 具象理解        假设有这样一个二维字母表（如图）和单词“ABCCED”： 有如下路径存在： 我们应该返回“tru...
数据结构与算法复习提纲与复习题
12-23
本文将简要介绍数据结构与算法复习提纲与复习题。数据结构是计算机科学的基础，它研究非数值计算的程序设计问题中，数据元素的逻辑结构、存储结构以及一组相关的运算等课程。在数据结构复习提纲第一章绪论中，我们将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值