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

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

数据结构与算法


中序线索化二叉树及其遍历

       将树线索化即让它闲置的节点指向中序遍历的下一位，n个节点共有2n个指针，但利用起来的只有n-1个，剩余n+1个中我们可以给其赋值指向中序的下一个节点。

节点类需要

       成员：

  1. 左子树
  2. 右子树
  3. 节点值
  4. Boolean类型变量两个，用于显示左，右子树是否为线索

       方法：

  1. 添加左右子树
package TenWeek;

import java.util.*;

public class BinaryThreadTree {
	
	public BinaryThreadTree left;
	public boolean isLeftThread;
	public BinaryThreadTree right;
	public boolean isRightThread;
	public Object value;
	
	public BinaryThreadTree(){}
	public BinaryThreadTree(Object x){this.value=x;}
	
	public void addLeft(Object x){this.left=new BinaryThreadTree(x);}
	
	public void addRight(Object x){this.right=new BinaryThreadTree(x);}
	
	public void visit(BinaryThreadTree p){System.out.print(p.value+", ");}
	
	public void levTravel(BinaryThreadTree p){
		if(p==null) return;
		
		Queue<BinaryThreadTree> q=new LinkedList<BinaryThreadTree>();
		q.offer(p);
		BinaryThreadTree 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();
	}
	/*
	这个方法用于根据先序遍历字符串构建树，其中，先序遍历样式为“ABD##E#G##CF###”
	表示A左子节点为B，B，左子节点为D，D为叶子节点······
	*/
	private static int static_i=0;
	public BinaryThreadTree getTreeFromString(String s){
		if(s.length()==0||s.equals("")) return null;
		
		BinaryThreadTree curnode=null;
		if(s.charAt(static_i)!='#'){
			curnode=new BinaryThreadTree(s.charAt(static_i));
			static_i++;
			curnode.left=getTreeFromString(s);
			curnode.right=getTreeFromString(s);
		}
		else static_i++;
		return curnode;
	}
	/*
	 * 用于判断树是否为完全二叉树
	 */
	public boolean isPerfect(BinaryThreadTree p){
		if(p==null) return true;
		
		BinaryThreadTree Left=null;
		BinaryThreadTree Right=null;
		BinaryThreadTree curnode;
		boolean isLeaf=false;
		Queue<BinaryThreadTree> q=new LinkedList<BinaryThreadTree>();
		q.offer(p);
		
		while(!q.isEmpty()){
			curnode=q.poll();
			Left=curnode.left;
			Right=curnode.right;
			
			if((Left==null&&Right!=null)||(isLeaf&&(Left!=null||Right!=null))) return false;
			if(Left!=null) q.offer(Left);
			if(Right!=null) q.offer(Right);
			else isLeaf=true;
		}
		return true;
	}
}

构建类需要

       成员：

  1. BinaryThreadTree类型的对象
  2. BinaryThreadTree类型的指针，用于指向前一个遍历的节点

       方法：

  1. 线索化
  2. 按线索化遍历
package TenWeek;

public class BinaryThreadTree_Thread {

	public static BinaryThreadTree pre;
	
	public static void inThread(BinaryThreadTree node){
		if(node==null) return;
		
		inThread(node.left);
		if(node.left==null){
			node.isLeftThread=true;
			node.left=pre;
		}
		if(pre!=null&&pre.right==null){
			pre.isRightThread=true;
			pre.right=node;
		}
		pre=node;
		inThread(node.right);
	}
	
	public static void visit(BinaryThreadTree p){System.out.print(p.value+", ");}
	
	public static void midTravel_inThread(BinaryThreadTree p){
		if(p==null) return;
		while(p!=null&&(!p.isLeftThread)) p=p.left;
		
		while(p!=null){
			visit(p);
			if(p.isRightThread) p=p.right;
			else{
				p=p.right;
				while(p!=null&&(!p.isLeftThread)) p=p.left;
			}
		}
	}
	
	public static void main(String args[]) throws Exception{
		BinaryThreadTree root = new BinaryThreadTree("A");
		
		root=root.getTreeFromString("ABD##E#G##CF###");
		
		System.out.println("isPerfect : "+root.isPerfect(root));
		System.out.println();
		
		inThread(root);
		System.out.println("MidTravel : ");
		midTravel_inThread(root);
	}
}

结果如下：

isPerfect : false
MidTravel :
D, B, E, G, A, F, C,

霍夫曼树

定义

       霍夫曼树。

实现

huffman节点类
package TenWeek;

import java.util.*;

public class HuffmanNode {
	
	public Object value;
	public int weight;//权重
	HuffmanNode left;
	HuffmanNode right;
	
	public HuffmanNode(Object x, int weight){
		this.value=x;
		this.weight=weight;
	}
	
	public String toString(){
		return "Node[vale=" + this.value + ",  weight=" + this.weight + "]";
	}
	
	public boolean has(HuffmanNode p, Object x){
		if(p==null) return false;
		if(p.value==x) return true;
		
		Queue<HuffmanNode> q=new LinkedList<HuffmanNode>();
		q.offer(p);
		HuffmanNode temp;
		while(!q.isEmpty()){
			temp=q.poll();
			if(temp.value==x) return true;
			if(temp.left!=null) q.offer(temp.left);
			if(temp.right!=null) q.offer(temp.right);
		}
		return false;
	}
	
	public boolean isPerfect(HuffmanNode p){
		if(p==null) return true;
		
		HuffmanNode left;
		HuffmanNode right;
		HuffmanNode curnode;
		boolean leaf=false;
		
		Queue<HuffmanNode> q=new LinkedList<HuffmanNode>();
		q.offer(p);
		
		while(!q.isEmpty()){
			curnode=q.poll();
			left=curnode.left;
			right=curnode.right;
			
			if((left==null&&right!=null)||(leaf)&&(left!=null||right!=null)) return false;
			if(left!=null) q.offer(left);
			if(right!=null) q.offer(right);
			else leaf=true;
		}
		return true;
	}
}
Huffman功能实现
package TenWeek;

import java.util.*;

public class HuffmanTree {
	
	public HuffmanNode node;
	
	public HuffmanNode creatHuffmanTree(List<HuffmanNode> nodes){
		
		while(nodes.size()>1){
			//Collections.sort((List<T>) nodes);
			sort(nodes);
			//权值从大到小
			HuffmanNode Left=nodes.remove(nodes.size()-1);
			HuffmanNode Right=nodes.remove(nodes.size()-1);
			HuffmanNode Parent=new HuffmanNode(null, Left.weight+Right.weight);
			
			Parent.left=Left;
			Parent.right=Right;
			nodes.add(Parent);
		}
		return nodes.get(0);
	}
	
	public void levTravel(HuffmanNode p){
		if(p==null) return;
		
		Queue<HuffmanNode> q=new LinkedList<HuffmanNode>();
		HuffmanNode temp;
		
		q.offer(p);
		while(!q.isEmpty()){
			temp=q.poll();
			if(temp==null) continue;
			System.out.print(temp.toString()+"\n");
			if(temp.left!=null) q.offer(temp.left);
			if(temp.right!=null) q.offer(temp.right);
		}
		System.out.println();
	}
	
	public String getBinary(HuffmanNode root, Object x, String s){
		if(root==null) return s;
		if(root.value==x) return s;
		if(root.left.has(root.left, x)) return getBinary(root.left, x, s+"0");
		if(root.right.has(root.right, x)) return getBinary(root.right, x, s+"1");
		else return "Sorry, we never find what you want.";
	}

	public void sort(List<HuffmanNode> nodes) {
		// TODO Auto-generated method stub
		for(int i=0;i<nodes.size()-1;i++)
			for(int j=0;j<nodes.size()-1;j++)
				if(nodes.get(j).weight<=nodes.get(j+1).weight)//注：是<=因为需要保证新合成的节点在与固有节点权重相同时max(I)最短
					swap(nodes, j);
	}

	private void swap(List<HuffmanNode> nodes, int j) {
		// TODO Auto-generated method stub
		HuffmanNode temp=nodes.remove(j);
		nodes.add(j+1, temp);
	}
}
Huffman检验
package TenWeek;

import java.util.*;

public class HuffmanTree_test {
	
	public static void main(String args[]){
		
		HuffmanTree t=new HuffmanTree();
		
		//test01
		List<HuffmanNode> L=new LinkedList<HuffmanNode>();
		HuffmanNode a=new HuffmanNode("a", 7);
		HuffmanNode b=new HuffmanNode("b", 8);
		HuffmanNode c=new HuffmanNode("c", 9);
		HuffmanNode d=new HuffmanNode("d", 15);
		L.add(a);
		L.add(b);
		L.add(c);
		L.add(d);
		
		HuffmanNode res01=t.creatHuffmanTree(L);
		System.out.println(res01.isPerfect(res01));
		t.levTravel(res01);
		
		//test02
		List<HuffmanNode> M=new LinkedList<HuffmanNode>();
		HuffmanNode a1=new HuffmanNode("m", 10);
		HuffmanNode b1=new HuffmanNode("s", 29);
		HuffmanNode c1=new HuffmanNode("t", 4);
		HuffmanNode d1=new HuffmanNode("a", 8);
		HuffmanNode e1=new HuffmanNode("q", 15);
		HuffmanNode f1=new HuffmanNode("k", 7);
		M.add(a1);
		M.add(b1);
		M.add(c1);
		M.add(d1);
		M.add(e1);
		M.add(f1);
		
		HuffmanNode res02=t.creatHuffmanTree(M);
		System.out.println(res02.isPerfect(res02));
		System.out.println("m: "+t.getBinary(res02, "m", ""));
		System.out.println("s: "+t.getBinary(res02, "s", ""));
		System.out.println("t: "+t.getBinary(res02, "t", ""));
		System.out.println("a: "+t.getBinary(res02, "a", ""));
		System.out.println("q: "+t.getBinary(res02, "q", ""));
		System.out.println("k: "+t.getBinary(res02, "k", ""));
		t.levTravel(res02);
		
		//test03
		List<HuffmanNode> N=new LinkedList<HuffmanNode>();
		HuffmanNode a2=new HuffmanNode("a", 15);
		HuffmanNode b2=new HuffmanNode("b", 3);
		HuffmanNode c2=new HuffmanNode("c", 14);
		HuffmanNode d2=new HuffmanNode("d", 2);
		HuffmanNode e2=new HuffmanNode("e", 6);
		HuffmanNode f2=new HuffmanNode("f", 9);
		HuffmanNode g2=new HuffmanNode("g", 16);
		HuffmanNode h2=new HuffmanNode("h", 17);
		N.add(a2);
		N.add(b2);
		N.add(c2);
		N.add(d2);
		N.add(e2);
		N.add(f2);
		N.add(g2);
		N.add(h2);
		HuffmanNode res03=t.creatHuffmanTree(N);
		t.levTravel(res03);
		
		//test04
		List<HuffmanNode> O=new LinkedList<HuffmanNode>();
		HuffmanNode i1=new HuffmanNode("i1", 5);
		HuffmanNode i2=new HuffmanNode("i2", 25);
		HuffmanNode i3=new HuffmanNode("i3", 3);
		HuffmanNode i4=new HuffmanNode("i4", 6);
		HuffmanNode i5=new HuffmanNode("i5", 10);
		HuffmanNode i6=new HuffmanNode("i6", 11);
		HuffmanNode i7=new HuffmanNode("i7", 36);
		HuffmanNode i8=new HuffmanNode("i8", 4);
		O.add(i1);
		O.add(i2);
		O.add(i3);
		O.add(i4);
		O.add(i5);
		O.add(i6);
		O.add(i7);
		O.add(i8);
		HuffmanNode res04=t.creatHuffmanTree(O);
		System.out.println("i1: "+t.getBinary(res04, "i1", ""));
		System.out.println("i2: "+t.getBinary(res04, "i2", ""));
		System.out.println("i3: "+t.getBinary(res04, "i3", ""));
		System.out.println("i4: "+t.getBinary(res04, "i4", ""));
		System.out.println("i5: "+t.getBinary(res04, "i5", ""));
		System.out.println("i6: "+t.getBinary(res04, "i6", ""));
		System.out.println("i7: "+t.getBinary(res04, "i7", ""));
		System.out.println("i8: "+t.getBinary(res04, "i8", ""));
		t.levTravel(res04);
	}
}

结果如下：

true
Node[vale=null, weight=39]
Node[vale=null, weight=15]
Node[vale=null, weight=24]
Node[vale=a, weight=7]
Node[vale=b, weight=8]
Node[vale=c, weight=9]
Node[vale=d, weight=15]

false
m: 101
s: 0
t: 1100
a: 100
q: 111
k: 1101
Node[vale=null, weight=73]
Node[vale=s, weight=29]
Node[vale=null, weight=44]
Node[vale=null, weight=18]
Node[vale=null, weight=26]
Node[vale=a, weight=8]
Node[vale=m, weight=10]
Node[vale=null, weight=11]
Node[vale=q, weight=15]
Node[vale=t, weight=4]
Node[vale=k, weight=7]

Node[vale=null, weight=82]
Node[vale=null, weight=33]
Node[vale=null, weight=49]
Node[vale=g, weight=16]
Node[vale=h, weight=17]
Node[vale=null, weight=20]
Node[vale=null, weight=29]
Node[vale=f, weight=9]
Node[vale=null, weight=11]
Node[vale=c, weight=14]
Node[vale=a, weight=15]
Node[vale=null, weight=5]
Node[vale=e, weight=6]
Node[vale=d, weight=2]
Node[vale=b, weight=3]

i1: 0110
i2: 10
i3: 0000
i4: 0111
i5: 001
i6: 010
i7: 11
i8: 0001
Node[vale=null, weight=100]
Node[vale=null, weight=39]
Node[vale=null, weight=61]
Node[vale=null, weight=17]
Node[vale=null, weight=22]
Node[vale=i2, weight=25]
Node[vale=i7, weight=36]
Node[vale=null, weight=7]
Node[vale=i5, weight=10]
Node[vale=i6, weight=11]
Node[vale=null, weight=11]
Node[vale=i3, weight=3]
Node[vale=i8, weight=4]
Node[vale=i1, weight=5]
Node[vale=i4, weight=6]

findover
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法——作业2
AliceRainly的博客
02-19 195
给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。 不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array 著作权归领扣网络所有。商业转载请...
数据结构与算法（作业六）
BryceFei的博客
03-01 278
买股票的最佳时机 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 注意你不能在买入股票前卖出股票。 运算代码如下： class Solution { public: int maxProfit(vector<int>& prices) { if (...
二叉树的创建（递归）
lemon25的博客
01-03 481
1、输入：ABD##E##CF#G###（创建二叉树） 2、输出：先序遍历：ABDECFG          中序遍历：DBEAFGC          后序遍历：DEBGFCA #include #include using namespace std; typedef struct BiTreeNode{ char date; struct BiTreeNode *lch
PTA习题：数据结构与算法题目集1
08-08
数据结构与算法是计算机科学的基础，它涉及到如何高效地存储和处理数据，以及设计和分析解决问题的方法。在这些题目中，我们将探讨三个不同主题：...因此，不断练习和学习数据结构与算法，对于提升IT专业技能非常有益。
数据结构与算法练习题.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构和算法练习题.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）...
算法与数据结构课后与习题解析
07-22
在这个PDF文档中，读者可以找到详尽的理论解释以及一系列的练习题，以帮助深化对算法和数据结构的理解。 一、算法基础 算法是一系列解决问题的明确指令，它描述了如何执行特定任务。在计算机科学中，算法的重要性...
二叉树基本操作的实现
嘘...一只bug
11-28 405
实验项目五：二叉树基本操作的实现 课程名称：数据结构 实验项目名称：二叉树基本操作的实现 实验目的： 1．掌握树的基本操作—遍历。 实验要求： 1、 分别用递归和非递归的方法实现一棵树的三种遍历。 实验过程： 1、 创建一棵二叉树（二叉树如下图所示）； 2、 用递归算法实现对该树的三种遍历； 3、 用非递归算法实现对该树的三种遍历； 4、 输入选项：0或1，0为递归遍...
c++模板实现二叉树，线索化，线索化遍历，非递归遍历及一些基本操作
ssopp24的博客
04-06 1042
c++模板类实现二叉树一些基本操作：前中后 遍历 及其 非递归遍历。  二叉树线索化， 及线索化后采用非递归方式遍历。  层序遍历。  叶子结点个数， k层节点个数， 二叉树深度， 查找元素等。 两个头文件， 一个是线索化有关， 另一个是别的操作 BinaryTree: #ifndef BINARY_TREE_H_ #define BINARY_TREE_H_ //树
【数据结构】——二叉树的创建、计算叶子结点个数、递归遍历
qq_43412060的博客
02-18 7352
前面我们讲了关于数据结构中的堆栈问题，这篇文章主要是为大家简要介绍一下二叉树，并实现二叉树的创建、计算叶子结点个数、递归遍历、判断是否是完全二叉树等相关问题~ 一、二叉树的介绍 1、什么是二叉树 一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树 的二叉树组成。 2、二叉树的特点 1、 每个结点最多有两棵子树，即二叉树不存在度大于2的结点。 2、 二叉树...
第九章　查找练习题
奋斗的PIG
04-25 9135
原文地址：第九章　查找练习题作者：tanzj 1、在对有二十个数据有序表作二分查找时有___________个结点的查找长度是4. 2、用折半查找法的查找速度比用顺序查找法的查找速度_________.       A  必然慢   B必然快     C速度相等      D   快慢不定 3、写出从循环单链表中查找出最大值的算法. 4、写出从循环单链表中查找出最小值的算法 . 5、适合折半
C++数据结构与算法笔记之实验八 二叉树构造及遍历
weixin_45823430的博客
04-22 2581
实验八 二叉树构造及遍历 实验目的 1.理解树形结构中结点和结点间关系的基本概念； 2.掌握二叉树的链式存储结构； 3.掌握二叉树结点的递归访问方法； 4.掌握二叉树的遍历。 实验环境 Windows 7以上版本的操作系统，Visual Studio 2010编程环境。 实验内容和步骤 1．根据以下的二叉树完成实验内容： 1)写出前序、中序和后序遍历序列； 前序：ABDECFG 中序：DBEAFGC 后序：DEBGFCA 2)分别写出单分支结点和叶子结点； 单分支节点：（度为1 ） CF 叶子节点：（度为
树与二叉树——左右子树交换
顶锅猫
09-19 366
题目： 将树所有节点的左、右子树交换。并输出交换后的先序列。 思路： 使用递归 需要的辅助参数 treenode *p； 子树交换 p = t->rchild; t->rchild = t->lchild; t->lchild = p; 对左右子树进行递归。 测试用例： ABD##E##CF##G## 结果 ：ACGFBED 代码实现： #include <iostream> using namespace std; #define MAX 20 typ
【数据结构】模拟实现二叉树（二叉树的实现，查找，前中后层序，深度，叶节点，K层，结点数）
qq_41152046的博客
04-03 220
1.概念 1.二叉树每个结点最多有两颗子树，且有左右之分，次序不能颠倒。 2.完全二叉树：K-1层结点为满，K层从左至右为连续。 3.满二叉树：二叉树的结点个数为2k-1,K-1层的左右子树（叶子）为满。 4.存储分为：链式和顺序。 链式可以直接通过指针访问: 顺序访问: 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点 parent = (i-1)/2...
二叉树基本操作集(创建、递归遍历、深度等)
风硕依源的博客
11-30 607
#include<stdio.h> #include<stdlib.h> typedef char ElemType; //二叉树存储结构 typedef struct BinNode{ ElemType Data; struct BinNode *Left, *Right;}*BinTree;
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.
数据结构与算法复习提纲与复习题
12-23
本文将简要介绍数据结构与算法复习提纲与复习题。数据结构是计算机科学的基础，它研究非数值计算的程序设计问题中，数据元素的逻辑结构、存储结构以及一组相关的运算等课程。在数据结构复习提纲第一章绪论中，我们将...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值