数据结构——浙大版中国大学mooc(week5)

数据结构——浙大版中国大学mooc(week10) 排序(下)课程给出代码10-排序4 统计工龄 (20 分)10-排序5 PAT Judge (25 分)10-排序6 Sort with Swap(0, i) (25 分) 课程给出代码 C语言:快速排序 /* 快速排序 - 直接调用库函数 */ #include <stdlib.h> /*---------------简单整数排序--------------------*/ ... 阅读详情

课程给出代码

C语言描述:堆的描述和操作

typedef struct HNode *Heap; /* 堆的类型定义 */
struct HNode {
    ElementType *Data; /* 存储元素的数组 */
    int Size;          /* 堆中当前元素个数 */
    int Capacity;      /* 堆的最大容量 */
};
typedef Heap MaxHeap; /* 最大堆 */
typedef Heap MinHeap; /* 最小堆 */
 
#define MAXDATA 1000  /* 该值应根据具体情况定义为大于堆中所有可能元素的值 */
 
MaxHeap CreateHeap( int MaxSize )
{ /* 创建容量为MaxSize的空的最大堆 */
 
    MaxHeap H = (MaxHeap)malloc(sizeof(struct HNode));
    H->Data = (ElementType *)malloc((MaxSize+1)*sizeof(ElementType));
    H->Size = 0;
    H->Capacity = MaxSize;
    H->Data[0] = MAXDATA; /* 定义"哨兵"为大于堆中所有可能元素的值*/
 
    return H;
}
 
bool IsFull( MaxHeap H )
{
    return (H->Size == H->Capacity);
}
 
bool Insert( MaxHeap H, ElementType X )
{ /* 将元素X插入最大堆H,其中H->Data[0]已经定义为哨兵 */
    int i;
  
    if ( IsFull(H) ) { 
        printf("最大堆已满");
        return false;
    }
    i = ++H->Size; /* i指向插入后堆中的最后一个元素的位置 */
    for ( ; H->Data[i/2] < X; i/=2 )
        H->Data[i] = H->Data[i/2]; /* 上滤X */
    H->Data[i] = X; /* 将X插入 */
    return true;
}
 
#define ERROR -1 /* 错误标识应根据具体情况定义为堆中不可能出现的元素值 */
 
bool IsEmpty( MaxHeap H )
{
    return (H->Size == 0);
}
 
ElementType DeleteMax( MaxHeap H )
{ /* 从最大堆H中取出键值为最大的元素,并删除一个结点 */
    int Parent, Child;
    ElementType MaxItem, X;
 
    if ( IsEmpty(H) ) {
        printf("最大堆已为空");
        return ERROR;
    }
 
    MaxItem = H->Data[1]; /* 取出根结点存放的最大值 */
    /* 用最大堆中最后一个元素从根结点开始向上过滤下层结点 */
    X = H->Data[H->Size--]; /* 注意当前堆的规模要减小 */
    for( Parent=1; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
 
    return MaxItem;
} 
 
/*----------- 建造最大堆 -----------*/
void PercDown( MaxHeap H, int p )
{ /* 下滤:将H中以H->Data[p]为根的子堆调整为最大堆 */
    int Parent, Child;
    ElementType X;
 
    X = H->Data[p]; /* 取出根结点存放的值 */
    for( Parent=p; Parent*2<=H->Size; Parent=Child ) {
        Child = Parent * 2;
        if( (Child!=H->Size) && (H->Data[Child]<H->Data[Child+1]) )
            Child++;  /* Child指向左右子结点的较大者 */
        if( X >= H->Data[Child] ) break; /* 找到了合适位置 */
        else  /* 下滤X */
            H->Data[Parent] = H->Data[Child];
    }
    H->Data[Parent] = X;
}
 
void BuildHeap( MaxHeap H )
{ /* 调整H->Data[]中的元素,使满足最大堆的有序性  */
  /* 这里假设所有H->Size个元素已经存在H->Data[]中 */
 
    int i;
 
    /* 从最后一个结点的父节点开始,到根结点1 */
    for( i = H->Size/2; i>0; i-- )
        PercDown( H, i );
}

C语言描述:集合的定义和并集操作

#define MAXN 1000                  /* 集合最大元素个数 */
typedef int ElementType;           /* 默认元素可以用非负整数表示 */
typedef int SetName;               /* 默认用根结点的下标作为集合名称 */
typedef ElementType SetType[MAXN]; /* 假设集合元素下标从0开始 */
 
void Union( SetType S, SetName Root1, SetName Root2 )
{ /* 这里默认Root1和Root2是不同集合的根结点 */
    /* 保证小集合并入大集合 */
    if ( S[Root2] < S[Root1] ) { /* 如果集合2比较大 */
        S[Root2] += S[Root1];     /* 集合1并入集合2  */
        S[Root1] = Root2;
    }
    else {                         /* 如果集合1比较大 */
        S[Root1] += S[Root2];     /* 集合2并入集合1  */
        S[Root2] = Root1;
    }
}
 
SetName Find( SetType S, ElementType X )
{ /* 默认集合元素全部初始化为-1 */
    if ( S[X] < 0 ) /* 找到集合的根 */
        return X;
    else
        return S[X] = Find( S, S[X] ); /* 路径压缩 */
}

05-树7 堆中的路径 (25 分)

将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。
输入格式:
每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。
输出格式:
对输入中给出的每个下标i,在一行中输出从H[i]到根结点的路径上的数据。数字间以1个空格分隔,行末不得有多余空格。

#include<stdio.h>

#define MAXN 1001
#define MINH -10001
int H[MAXN],size;

void Insert(int x){
	int i;
	for(i=++size; H[i/2]> x; i/=2 )
		H[i]=H[i/2];
	H[i]=x;
}

void Creat(int n){
	int i,x;
	H[0]=MINH;
	size=0;
	for(i=0;i<n;i++){
		scanf("%d",&x);
		Insert(x);
	}
}

void Print(int m){
	int i,j;
	for(i=0;i<m;i++){
		scanf("%d",&j);
		printf("%d",H[j]);
		while(j>1){
			j/=2;
			printf(" %d",H[j]);
		}
		printf("\n");
	}
}

int main(){
	int n,m;
	scanf("%d %d",&n,&m);
	Creat(n);
	Print(m);
    return 0;
}

05-树8 File Transfer (25 分)

We have a network of computers and a list of bi-directional connections. Each of these connections allows a file transfer from one computer to another. Is it possible to send a file from any computer on the network to any other?

Input Specification:
Each input file contains one test case. For each test case, the first line contains N (2≤N≤10^4​ ), the total number of computers in a network. Each computer in the network is then represented by a positive integer between 1 and N. Then in the following lines, the input is given in the format:

#include<stdio.h>

#define MAXN 10000

typedef int SetType[MAXN];

int Find(SetType S, int n){
	if (S[n]<0)
		return n;
	else
		return S[n]=Find(S, S[n]);
}

void Union(SetType S, int a, int b){
	if (S[a]> S[b])
		S[a]=b;
	else{
		if(S[a]==S[b])
			S[a]--;
		S[b]=a;	
	}
}

void Insert( SetType S){
	int a, b;
	int m, n;
	scanf("%d %d",&a, &b);
	m=Find(S, a-1);
	n=Find(S, b-1);
	if(m!=n)
		Union(S, m, n);
}

void Initialization(SetType S, int n){
	for(int i=0;i<n;i++)
		S[i]=-1;
}

void Check( SetType S){
	int a, b;
	int m, n;
	scanf("%d %d",&a, &b);
	m=Find(S, a-1);
	n=Find(S, b-1);
	if(m!=n)
		printf("no\n");
	else
		printf("yes\n");
}

void Finish( SetType S,int n){
	int i,counter=0;
	for(i=0;i<n ;i++){
		if(S[i]<0)
			counter++;
	}
	if(counter==1)
		printf("The network is connected.\n");
	else
		printf("There are %d components.\n",counter);
}

int main(){
	SetType S;
	int n;
	char c;
	scanf("%d\n",&n);
	Initialization(S,n);
	do{
		scanf("%c",&c);
		switch(c){
			case 'I': Insert(S);break;
			case 'C': Check(S);break;
			case 'S': Finish(S,n);break;
		}
	}while(c!='S');
	return 0;
}

05-树9 Huffman Codes (30 分)

In 1953, David A. Huffman published his paper “A Method for the Construction of Minimum-Redundancy Codes”, and hence printed his name in the history of computer science. As a professor who gives the final exam problem on Huffman codes, I am encountering a big problem: the Huffman codes are NOT unique. For example, given a string “aaaxuaxz”, we can observe that the frequencies of the characters ‘a’, ‘x’, ‘u’ and ‘z’ are 4, 2, 1 and 1, respectively. We may either encode the symbols as {‘a’=0, ‘x’=10, ‘u’=110, ‘z’=111}, or in another way as {‘a’=1, ‘x’=01, ‘u’=001, ‘z’=000}, both compress the string into 14 bits. Another set of code can be given as {‘a’=0, ‘x’=11, ‘u’=100, ‘z’=101}, but {‘a’=0, ‘x’=01, ‘u’=011, ‘z’=001} is NOT correct since “aaaxuaxz” and “aazuaxax” can both be decoded from the code 00001011001001. The students are submitting all kinds of codes, and I need a computer program to help me determine which ones are correct and which ones are not.

Input Specification:
Each input file contains one test case. For each case, the first line gives an integer N (2≤N≤63), then followed by a line that contains all the N distinct characters and their frequencies in the following format:

c[1] f[1] c[2] f[2] … c[N] f[N]
where c[i] is a character chosen from {‘0’ - ‘9’, ‘a’ - ‘z’, ‘A’ - ‘Z’, ‘_’}, and f[i] is the frequency of c[i] and is an integer no more than 1000. The next line gives a positive integer M (≤1000), then followed by M student submissions. Each student submission consists of N lines, each in the format:

c[i] code[i]
where c[i] is the i-th character and code[i] is an non-empty string of no more than 63 '0’s and '1’s.

Output Specification:
For each test case, print in each line either “Yes” if the student’s submission is correct, or “No” if not.

Note: The optimal solution is not necessarily generated by Huffman algorithm. Any prefix code with code length being optimal is considered correct.


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define Maxn 64
 
int N, w[Maxn];
char ch[Maxn];
int codelen, cnt1, cnt2;
 
typedef struct TreeNode* Tree;
struct TreeNode {
    int Weight;
    Tree Left, Right;
};
 
typedef struct HeapNode* Heap;
struct HeapNode {
    struct TreeNode Data[Maxn];
    int Size;
};
 
Tree CreatTree() {
    Tree T;
    T = (Tree)malloc(sizeof(struct TreeNode));
    T->Left = T->Right = NULL;
    T->Weight = 0;
    return T;
}
 
Heap CreatHeap() {
    Heap H;
    H = (Heap)malloc(sizeof(struct HeapNode));
    H->Size = 0;
    H->Data[0].Weight = -1;
    return H;
}
 
void Insert(Heap H, struct TreeNode T) {
    int i = ++H->Size;
    for( ; T.Weight < H->Data[i/2].Weight; i /= 2)
        H->Data[i] = H->Data[i/2];
    H->Data[i] = T;
}
 
Tree Delete(Heap H) {
    int parent, child;
    struct TreeNode Temp = H->Data[H->Size--];
    Tree T = CreatTree();
    *T = H->Data[1];
    for(parent = 1; 2*parent <= H->Size; parent = child) {
        child = 2 * parent;
        if(child != H->Size && H->Data[child].Weight > H->Data[child+1].Weight) child++;
        if(Temp.Weight < H->Data[child].Weight) break;
        H->Data[parent] = H->Data[child];
    }
    H->Data[parent] = Temp;
    return T;
}
 
Tree Huffman(Heap H) {
    Tree T = CreatTree(); //分配空间
    while(H->Size != 1) {
        T->Left = Delete(H);
        T->Right = Delete(H);
        T->Weight = T->Left->Weight + T->Right->Weight;
        //printf("l = %d, r = %d, t = %d\n", T->Left->Weight, T->Right->Weight, T->Weight);
        Insert(H, *T);
    }
    T = Delete(H);
    return T;
}
 
void PreTravel(Tree T) {
    if(T) {
        printf("%d ", T->Weight);
        PreTravel(T->Left);
        PreTravel(T->Right);
    }
}
 
int WPL(Tree T, int Depth) {
    if(!T->Left && !T->Right) 
    	return Depth*T->Weight; 
    else 
    	return WPL(T->Left, Depth+1) + WPL(T->Right, Depth+1);
}
 
void JudgeTree(Tree T) {
    if(T) {
        if(T->Left && T->Right) cnt2++;
        else if(!T->Left && !T->Right) cnt1++;
        else cnt1 = 0;
        JudgeTree(T->Left);
        JudgeTree(T->Right);
    }
}
 
int Judge() {
    int i, j, wgh, flag = 1;
    char s1[Maxn], s2[Maxn];
    Tree T = CreatTree(), pt = NULL;
    for(i = 0; i < N; i++) {
        scanf("%s%s", s1, s2);
        if(strlen(s2) > N) return 0;
        for(j = 0; s1[0] != ch[j]; j++); wgh = w[j];
        pt = T;//每次建树前先将指针移动到根节点上;
        for(j = 0; s2[j]; j++) {
            if(s2[j] == '0') {
                if(!pt->Left) pt->Left = CreatTree();
                pt = pt->Left;
            }
            if(s2[j] == '1') {
                if(!pt->Right) pt->Right = CreatTree();
                pt = pt->Right;
            }
            if(pt->Weight) flag = 0;
            if(!s2[j+1]) {
                if(pt->Left || pt->Right) flag = 0;//判断是否为前缀
                pt->Weight = wgh;
            }
            //printf("w = %d\n", pt->Weight);
        }
    }
    if(!flag) return 0;
    cnt1 = cnt2 = 0;
    JudgeTree(T);//判断是否不存在度数1的节点
    if(cnt1 != cnt2 + 1) return 0;
    //printf("wpl = %d\n", WPL(T, 0));
    if(codelen == WPL(T, 0)) return 1;
    else return 0;
}
 
int main() {
    int i, n;
    Heap H;
    Tree T;
    H = CreatHeap();
    T = CreatTree();
    scanf("%d", &N);
    for(i = 0; i < N; i++) {
        getchar();
        scanf("%c %d", &ch[i], &w[i]);
        H->Data[H->Size].Left = H->Data[H->Size].Right = NULL;
        T->Weight = w[i];
        Insert(H, *T);
    }
    //for(i = 1; i <= H->Size; i++) printf("%d ", H->Data[i].Weight);
    T = Huffman(H);     //PreTravel(T);
    codelen = WPL(T, 0);
    scanf("%d", &n);
    while(n--) {
        if(Judge()) printf("Yes\n");
        else printf("No\n");
    }
    return 0;
}

没时间做了代码思路1,代码思路2,代码思路3。

浙大PTA 函数题 05-树7 堆中的路径 (25 分)(C++) 思路: 并不难,可以用数组来表示最小堆,从下标为1的位置开始存入数据,i表示下标,则i/2就是父节点的位置,不过要记得在下标为0的位置设置哨兵,这回简化代码。 运行结果: 代码如下: #include<iostream> using namespace std; #define Max 1001 #define Flag -100001 int H[Max]; void Insert(int size,int data) { int i; for (i =size + 1; H 阅读详情

相关推荐

PTA 7-5 堆中的路径 (25 分) 建堆方式/STL方式

一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。 输入格式: 每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。 输出格式: 对输入中给出的每个下标i,在一行中输出从H[i]到根结点的...

巴拉拉小魔芋 876

堆的实现 (L2-012 关于堆的判断 (25 分))

堆 堆分成大顶堆和小顶堆,大根堆要求根节点的关键字既大于或等于左子树的关键字值,又大于或等于右子树的关键字值。小顶堆相反。 —————————————————————————————— 一堆的建立(以小顶堆为例) 建立一个堆 我们最关键的是需要一个上调函数,代码如下 void up(int i){ if(i == 1) return; int flag = 0; whil...

cp0328的博客 5139

从零组装电赛送药小车:OpenMV视觉核心+STM32控制,我的软硬件联调全记录

本文详细记录了从零构建电赛智能送药小车的全过程,重点解析了OpenMV视觉识别与STM32控制的深度协同方案。通过硬件选型对比、通信协议设计、PID调参等实战经验,解决了巡线精度、十字路口识别等核心问题,最终实现稳定可靠的送药小车系统,助力电子设计竞赛取得优异成绩。

weixin_42641741的博客 449

浙大数据结构习题笔记:05-树7 堆中的路径 (25分)

05-树7 堆中的路径 (25分) 原题 将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。 输入格式: 每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。 输出格式: 对输入中给出的每个下标i,在一行中输出从H[i]到根结点的路径上的数据。数字间以1个空格分隔,行末不得有多余空格。 输入样例: 5 3

Jimobbb的博客 774

嵌入式调光控制库:轻量级软启/渐变/记忆逻辑实现

调光控制是智能照明系统的核心基础功能,涉及亮度调节、人机交互与电气安全多重需求。其底层原理依赖于对相位角或PWM占空比的精确时序控制,并需融合软启动、渐变过渡、状态记忆等工程化逻辑。这类轻量级调光行为逻辑层,不直接操作硬件寄存器,而是以确定性、无动态内存、可配置的方式封装用户意图到目标亮度值(0–100%)的映射过程,显著提升产品鲁棒性与跨平台复用能力。广泛应用于TRIAC交流调光、LED直流PWM驱动及DALI/Matter等智能照明协议网关中,尤其适合资源受限的Cortex-M系列MCU和FreeRTO

weixin_28949937的博客 579

七步设计高频变压器

七步设计高频变压器

m0_71394959的博客 5405

【数据结构】2.树

声明:本文为个人在同步学习中国大学MOOC《数据结构(陈越、何钦铭)》(视频地址:https://www.icourse163.org/learn/ZJU-93001#/learn/content) 结合课件PPT所做的个人学习笔记,未经授权,禁止转载!但是您可以关注我的公众号“分享猿”,来获取此数据结构笔记(包括word版,pdf版,以及MarkDown版本),以及课件PPT,您需要关注后回复...

蓝图的博客 878

告别迷茫!手把手教你用Synopsys VC USB VIP搭建验证平台(附UVM分层序列实战解析)

本文详细介绍了如何使用Synopsys VC USB VIP搭建验证平台,并深入解析UVM分层序列的实战应用。通过Step-by-Step的操作指南和关键配置示例,帮助验证工程师高效集成USB VIP,掌握从环境搭建到测试用例开发的全套技能,特别适合处理复杂协议验证的挑战。

weixin_42520573的博客 556

堆中的路径

7-2 堆中的路径(25 分)将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。输入格式:每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。输出格式:对输入中给出的每个下标i,在一行中输出从H...

七九河开的博客 649

Windows 上安装 OpenCode 完全指南:从零到成功,人人能看懂!

跟着这篇教程,你应该已经成功在 Windows 上安装并运行了 OpenCode。步骤操作要点1安装 Chocolatey必须以管理员身份运行 PowerShell2安装 OpenCode3验证安装关闭并重新打开终端,输入4进入项目目录必须是 Git 仓库(git init5配置模型输入/connect,输入 API Key6开始使用输入问题测试最后的小建议如果没有 API Key,可以从 DeepSeek 或 Kimi 开始,有免费额度初次使用建议先在简单项目上测试。

专注于编程、AI、人工智能等多个领域内容研究和分析 3899

【ARFoundation自学04】AR Tracked Image 图像追踪识别与对应类的调用

1.添加组件 2.创建图像识别库 3.创建识别后追踪的物体(UI、模型等)

leoysq的博客 2560

数据结构与算法题目集(中文) - 7-5 堆中的路径(25 分)

题目链接:点击打开链接题目大意:略。解题思路:略。AC 代码#include&lt;bits/stdc++.h&gt; #include&lt;cmath&gt; #define mem(a,b) memset(a,b,sizeof a); using namespace std; typedef long long ll; const int maxn=1010; const int m...

958

华为OD技术面真题 - Python开发 - 2

汇总华为OD技术面八股Python八股,高频技术真题并提供详细解答。

qq_45776114的博客 912

数据结构——浙大版中国大学mooc(week9)

排序(上)课程给出代码09-排序1 排序 (25 分)09-排序2 Insert or Merge (25 分)09-排序3 Insertion or Heap Sort (25 分) 课程给出代码 C语言:插入排序 void InsertionSort( ElementType A[], int N ) { /* 插入排序 */ int P, i; ElementType T...

CodingW的博客 403

【系统分析师】高分论文:论面向对象设计方法及应用

本文以某市职业院校合并后的信息化系统建设项目为例,探讨了面向对象设计方法在系统开发中的应用。作为系统分析师,作者在415.6万元、6个月工期的项目中,通过遵循单一职责原则(简化构件库)、依赖倒置原则(开发公共接口)和开闭原则(构件扩展)等设计原则,成功完成了5个子系统融合改造和4个智慧实训室建设。项目采用J2EE分层设计和SOA架构,最终在2022年11月顺利上线,提升了教学管理效率,获得用户好评。文章总结了设计原则对提高系统复用性、可维护性的重要作用,同时也反思了部署过程中的经验教训。

数据知道的博客 7955

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

数据结构——浙大版中国大学mooc(week7)

图(中)课程给出代码07-图4 哈利·波特的考试 (25 分)07-图5 Saving James Bond - Hard Version (30 分)07-图6 旅游规划 (25 分) 课程给出代码 C语言:邻接表存储 - 无权图的单源最短路算法 /* 邻接表存储 - 无权图的单源最短路算法 */ /* dist[]和path[]全部初始化为-1 */ void Unweighted ( L...

CodingW的博客 485

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

数据结构——浙大版中国大学mooc(week4)

树(中)课程给出代码课程给出代码课程给出代码课程给出代码课程给出代码 课程给出代码 C语言表示二叉搜索树的插入和搜索 BinTree Insert( BinTree BST, ElementType X ) { if( !BST ){ /* 若原树为空,生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)...

CodingW的博客 315

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

【数据结构】堆 笔记

什么是堆 优先队列(Priority Queue):特殊的“队列”,取出元素的顺序是依照元素的优先权(关键字)大小,而不是元素进入队列的先后顺序。 若采用数组或链表实现优先队列 数组 : 插入 — 元素总是插入尾部 ~ Θ\ThetaΘ ( 1 ) 删除 — 查找最大(或最小)关键字 ~ Θ\ThetaΘ ( n ) 从数组中删去需要移动元素 ~ O( n ) 链表: 插入 — 元素总是插入...

Sicilly的博客 267

05-树7 堆中的路径 (25 分)

将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。 输入格式: 每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。 输出格式: 对输入中给出的每个下标i,在一行中输出从H[i]到根结点...

YelloJesse的博客 368

Java_week5

   Static 是一个修饰符,用于修饰成员(成员变量,成员函数) 当成员被静态修饰后,就多了一个调用方式,除了可以被对象调用外,还可以直接被类名调用。类名.静态成员 Jvm :虚拟机 Jvm 在调用主函数时,传入的是new String[0]; 因为学习JAVA基础,感觉跟不上进度所以抓紧学习基础的同时,学习其他内容。 Html:网页语言 由标签组成 Body 中...

weixin_30508241的博客 181

7-5 堆中的路径 (25分)

7-5 堆中的路径 (25分) 将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。 输入格式: 每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。 输出格式: 对输入中给出的每个下标i,在一行中输出从H[i]到根结点的路径上的数据。数字间以1个空格分隔,行末不得有多余空格。 输入样例: 5 3 46 2

Gyibin的博客 174

慕课浙大数据结构-05-树7 堆中的路径 (25分)

参考这篇文章,以及慕课中堆插入的讲解,并参考这篇文章05-树7 堆中的路径 (25分) 错误1: ph->element = (int*)malloc((n+1)*sizeof(int));//忘记给数组分配空间了 错误2: //这里需要加一个判断堆满了么 if(ph->size==ph->maxsize){/ return; } 如果满了就不插入,试了一下,不加判断...

weixin_43919570的博客 298

pta7-5 堆中的路径 (25分)

将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。 输入格式: 每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。 输出格式: 对输入中给出的每个下标i,在一行中输出从H[i]到根结点的路径上的数据。数字间以1个空格分隔,行末不得有多余空格。 输入样例: 5 3 46 23 26 24 1

suntingsheng123的专栏 354

05-树7 堆中的路径 (25分)

05-树7 堆中的路径 (25分) 将一系列给定数字插入一个初始为空的小顶堆H[]。随后对任意给定的下标i,打印从H[i]到根结点的路径。 输入格式: 每组测试第1行包含2个正整数N和M(≤1000),分别是插入元素的个数、以及需要打印的路径条数。下一行给出区间[-10000, 10000]内的N个要被插入一个初始为空的小顶堆的整数。最后一行给出M个下标。 输出格式: 对输入中给出的每个下标i,在一行中输出从H[i]到根结点的路径上的数据。数字间以1个空格分隔,行末不得有多余空格。 输入样例: 5 3 46

LaddC的博客 227

7-5 堆中的路径 (25 分)

堆的特点: 每个父节点都大于等于(或者小于等于)其所有后代结点。 堆的根节点含有堆中最大(或者最小)的对象。 堆中以任意节点为根节点的子树仍然是堆。 重点: 不是建立堆 给一个数组 int a[] ...

qq_42882717的博客 507

MOOC 数据结构 | 5. 树(下)

1. 什么是堆 例:CPU调度 优先队列(Priority Queue):特殊的“队列”,取出元素的顺序是依照元素的优先权(关键字)大小,而不是元素进入队列的先后顺序。 若采用数组或链表实现优先队列 数组: 插入--- 元素总是插入尾部 ~ 删除--- 查找最大(或最小)关键字 ~ ...

明朗晨光的专栏 791
上一篇: 数据结构——浙大版中国大学mooc(week4)
下一篇: 数据结构——浙大版中国大学mooc(week6)
CodingW
博客等级 码龄8年 3粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值