作业5

最新推荐文章于 2023-06-10 13:01:31 发布
最新推荐文章于 2023-06-10 13:01:31 发布
阅读量609 收藏 2
点赞数
分类专栏： 算法设计与分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53625091/article/details/116134418
版权

大部分代码从网上看的

  • 6-26 划分整数数组 (20 分)


    int pivotkey,low=0,low0=0,high=n-1,high0=n-1,flag=1,k=n/2,i;
    int s1=0,s2=0;
    while(flag){
        pivotkey=a[low]; //选择枢轴
        while(low<high){  //基于枢轴对数据记性划分
            while(low<high && a[high]>=pivotkey) --high;
            if(low!=high) a[low]=a[high];
            while(low<high && a[low]<=pivotkey) ++low;
            if(low!=high) a[high]=a[low];
        }
        a[low]=pivotkey;
        if(low==k-1) //若枢轴是第n/2个元素，划分成功
        flag=0;
        else if(low<k-1){
            low0=++low;
            high=high0;
        }else{
            high0=--high;
            low=low0;
        }
    } 
    for(i=0;i<k;i++) s1+=a[i];
    for(i=k;i<n;i++) s2+=a[i];
    return s2-s1;
// 参考1https://blog.csdn.net/qq_30091945/article/details/78117562
// 参考2https://andyguo.blog.csdn.net/article/details/106035854
  • 6-27 判断两棵二叉树是否同构（递归法） (10 分)
bool Isomorphism(BiTree T1,BiTree T2)
{   
    if(T1 && !T2) return false;
    
    if(!T1 && T2) return false;
    
    if(!T1 && !T2) return true;

    bool f1 = true,f2 = true;
    f1 = Isomorphism(T1->lchild,T2->lchild);
    f2 = Isomorphism(T1->rchild,T2->rchild);
    return f1 && f2;
}
  • 6-28
int height(AVLTree T)
{
    if(T == NULL) return 0;
    return T->Height;
}

void update(AVLTree T)
{
    int h1 = height(T->Left),h2 = height(T->Right);
    if(h1 > h2){
        T->Height = h1 + 1;
    }else{
        T->Height = h2 + 1;
    }
}

int get_blance(AVLTree T)
{
    int height1 = height(T->Left) - height(T->Right);
    return height1;
}

AVLTree R(AVLTree T)
{
    AVLTree p = T->Left;
    T->Left = p->Right;
    p->Right = T;
    update(T),update(p);
    return p;
}

AVLTree L(AVLTree T)
{
    AVLTree p = T->Right;
    T->Right = p->Left;
    p->Left = T;
    update(T),update(p);
    return p;
}


AVLTree Insert ( int Key, AVLTree T )
{
    if(T == NULL) {
        T = malloc(sizeof(struct AVLNode));
        T->Data = Key;
        T->Left = T->Right = NULL;
    }else if(Key < T->Data){
        T->Left = Insert(Key,T->Left);
        if(get_blance(T) == 2){
            if(get_blance(T->Left) == 1) T = R(T);
            else{
                T->Left = L(T->Left);
                T = R(T);
            }
        }
    }else{
        T->Right = Insert(Key,T->Right);
        if(get_blance(T) == -2){
            if(get_blance(T->Right) == -1) T = L(T);
            else{
                T->Right = R(T->Right);
                T = L(T);
            }
        }
    }
    update(T);
    
    return T;
}
// https://blog.csdn.net/m0_37907797/
  • 6-29
void HeapAdjust( HeapType  H, int s, int m){
	//假设r[s+1..m]已经是堆，将r[s..m]调整为以r[s]为根的大根堆
	KeyType rc;
	int j;
	rc=H.elem[s];
    for(j=2*s;j<=m;j*=2)
	{												//沿key较大的孩子结点向下筛选
		if(j<m&&H.elem[j]<H.elem[j+1]) ++j;		//j为key较大的记录的下标
        if(rc>=H.elem[j]) break;      			//rc应插入在位置s上
		H.elem[s]=H.elem[j]; s=j; 
    }
	H.elem[s]=rc;                          			//插入
}
  • 6-30
int insertIntoHeap(struct Heap* h, int x){
	if(h->size==h->capacity)
	return 0;
	int i;
	i=++h->size;
	for(;x<h->data[i/2];i/=2)
	{
        h->data[i]=h->data[i/2];
        if (i/2 == 0) break;
    }
	h->data[i]=x;
	return 1;
}
int deleteMin(struct Heap* h, int* pElement){
	if(h->size==0)
	return 0;
	*pElement=h->data[1];
	int temp=h->data[h->size--];
	int parent,child;
	for(parent=1;parent*2<=h->size;parent=child){
		child=parent*2;
		if((child!=h->size)&&(h->data[child]>h->data[child+1]))
		child++;
		if(temp<=h->data[child])
		break;
		else
		h->data[parent]=h->data[child];
	}
	h->data[parent]=temp;
	return 1;
}
  • 7-28
#include <bits/stdc++.h>
using namespace std;

const int N = 2e6 + 10;
int a[N];

int main()
{
    ios::sync_with_stdio(false);
    int n,k;
    cin >> n >> k;
    
    for(int i = 0;i < n;i ++)
        cin >> a[i];
    sort(a,a+n);
    cout << a[n-k] << endl;
    
    return 0;
}
  • 7-29
3    3    4    4    8    8    9    9    
3    2    0    4    8    7    7    9    
5    2    2    6    10   10   7    11   
5    5    6    6    1    10   11   11   
13   13   14   1    1    18   19   19   
13   12   14   14   18   18   17   19   
15   12   12   16   20   17   17   21   
15   15   16   16   20   20   21   21
  • 7-30
1 2 3 4 5 6 7 8 
2 1 4 3 6 5 8 7 
3 4 1 2 7 8 5 6 
4 3 2 1 8 7 6 5 
5 6 7 8 1 2 3 4 
6 5 8 7 2 1 4 3 
7 8 5 6 3 4 1 2 
8 7 6 5 4 3 2 1
  • 7-31
#include <bits/stdc++.h>
using namespace std;

const int N = 1e6 + 10;

int a[N];
int n,k;
int BinarySearch1(int x)
{
    int l = 0,r = n - 1;
    while(l < r){
        int mid = l + r >> 1;
        if(a[mid] < x){
            l = mid + 1;   
        }else{
            r = mid;
        }
    }
    return l;
}


int BinarySearch2(int x)
{
    int l = 0,r = n - 1;
    while(l < r){
        int mid = l + r + 1 >> 1;
        if(a[mid] > x){
            r = mid - 1;   
        }else{
            l = mid;
        }
    }
    return l;
}
int main()
{

    cin >> n >> k;
    for(int i = 0;i < n;i ++) cin >> a[i];
    if(k < a[0]){
        cout << "-1 0" << endl;
    }else if(k > a[n - 1]){
        cout << n - 1 << ' ' << n << endl;
    }else{
        int l1 = BinarySearch1(k);
        int l2 = BinarySearch2(k);
        cout << l2 << ' ' << l1 << endl;
    }
    
    return 0;
}
  • 7-32
#include <bits/stdc++.h>
using namespace std;

const int N = 1e6 + 10;

int a[N];
int n,k;
typedef long long LL;
int main()
{
    cin >> n;
    for(int i = 0,x;i < n;i ++)
        cin >> x >> a[i];
    sort(a,a+n);
    
    int mid = a[n >> 1];
    LL sum = 0;
    for(int i = 0;i < n;i ++){
        sum += fabs(a[i] - mid);
    }
    cout << sum << endl;

    return 0;
}

/*
1,3,8
4-1+4-3+8-4



*/
  • 7-33
#include <bits/stdc++.h>
using namespace std;

const int N = 1e6 + 10;

int a[N];
int n,k;
int BinarySearch1(int x)
{
    int l = 0,r = n - 1;
    while(l < r){
        int mid = l + r >> 1;
        if(a[mid] < x){
            l = mid + 1;   
        }else{
            r = mid;
        }
    }
    return l;
}


int BinarySearch2(int x)
{
    int l = 0,r = n - 1;
    while(l < r){
        int mid = l + r + 1 >> 1;
        if(a[mid] > x){
            r = mid - 1;   
        }else{
            l = mid;
        }
    }
    return l;
}
int main()
{
    ios::sync_with_stdio(false);
    
    cin >> n >> k;
    for(int i = 0;i < n;i ++) cin >> a[i];
    if(k < a[0]){
        cout << a[0] << endl;
    }else if(k > a[n - 1]){
        cout << a[n - 1] << endl;
    }else{
        int l1 = BinarySearch1(k);
        int l2 = BinarySearch2(k);
        int f1 = k - a[l2],f2 = a[l1] - k;
        if(f1 <= f2){
            cout << a[l2] << endl;
        }else{
            cout << a[l1] << endl;
        }
    }
    
    return 0;
}
  • 7-34
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 30;

int l[N], r[N], v[N], h[N], idx;

void update(int u)
{
    h[u] = max(h[l[u]], h[r[u]]) + 1;
}

void R(int& u)
{
    int p = l[u];
    l[u] = r[p], r[p] = u;
    update(u), update(p);
    u = p;
}

void L(int& u)
{
    int p = r[u];
    r[u] = l[p], l[p] = u;
    update(u), update(p);
    u = p;
}

int get_balance(int u)
{
    return h[l[u]] - h[r[u]];
}

void insert(int& u, int w)
{
    if (!u) u = ++ idx, v[u] = w;
    else if (w < v[u])
    {
        insert(l[u], w);
        if (get_balance(u) == 2)
        {
            if (get_balance(l[u]) == 1) R(u);
            else L(l[u]), R(u);
        }
    }
    else
    {
        insert(r[u], w);
        if (get_balance(u) == -2)
        {
            if (get_balance(r[u]) == -1) L(u);
            else R(r[u]), L(u);
        }
    }

    update(u);
}

int main()
{
    int n, root = 0;
    cin >> n;

    while (n -- )
    {
        int w;
        cin >> w;
        insert(root, w);
    }

    cout << v[root] << endl;

    return 0;
}
  • 7-35
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>

using namespace std;

void PrintHeap(vector<int>& Minimum_heap);
int main()
{
    int n, k, m;
    scanf("%d%d", &n, &k);//n是堆的容量，需创建一个容量为n的堆。
    //接下来k行，是对这个堆的依次的k项插入或删除操作：用 1 x 表示插入元素x；
    //用 -1 表示删除堆顶。
    vector<int> minHeap_1, minHeap_2;
    make_heap(minHeap_1.begin(), minHeap_1.end(), greater<int>());
    int operate_number, insert_number, i;
    for(i = 0; i < k; i++)
    {
        scanf("%d", &operate_number);
        if(operate_number == 1)
        {
            scanf("%d", &insert_number);
            if((int)minHeap_1.size() < n)//堆满则不能插入元素
            {
                minHeap_1.push_back(insert_number);
                push_heap(minHeap_1.begin(), minHeap_1.end(), greater<int>());
            }
            PrintHeap(minHeap_1);
        }
        else if(operate_number == -1)
        {
            if(!minHeap_1.empty())//堆空不可删除
            {
                pop_heap(minHeap_1.begin(), minHeap_1.end(), greater<int>());
                minHeap_1.pop_back();
            }
            PrintHeap(minHeap_1);
        }
    }
    scanf("%d", &m);
    for(int i = 0; i < m; i++)
    {
        scanf("%d", &insert_number);
        minHeap_2.push_back(insert_number);
    }
    make_heap(minHeap_2.begin(), minHeap_2.end(), greater<int>());
    //这一步尤其关键，执行了这一句后会对vector中所有的元素做调整，使之
    //成为一个最小堆
    PrintHeap(minHeap_2);
    return 0;
}
void PrintHeap(vector<int>& Minimum_heap)
{
    int heap_size = Minimum_heap.size();
    vector<int>::iterator ptr = Minimum_heap.begin();
    for (int i = 1; i < heap_size; i++, ptr++)
    {
        printf("%d ", *ptr);
    }
    printf("%d\n", *ptr);
}
  • 7-36
#include <bits/stdc++.h>
using namespace std;

const int N = 30;
int l[N],r[N],e[N],idx;
int h[N];
int n;

void update(int u)
{
    h[u] = max(h[l[u]],h[r[u]]) + 1;
}

int get_balance(int u)
{
    return h[l[u]] - h[r[u]];
}

void R(int &u)
{
    int p = l[u];
    l[u] = r[p];
    r[p] = u;
    update(u),update(p);
    u = p;
}
void L(int &u)
{
    int p = r[u];
    r[u] = l[p];
    l[p] = u;
    update(u),update(p);//更新高度。
    u = p;
}



void insert(int &u,int val)
{
    if(u == -1) e[idx] = val,u = idx ++;
    else if(val < e[u]){
        insert(l[u],val);
        if(get_balance(u) == 2){
            if(get_balance(l[u]) == 1) R(u);
            else L(l[u]),R(u);
        }
    }else{
        insert(r[u],val);
        if(get_balance(u) == -2){
            if(get_balance(r[u]) != -1) R(r[u]);
            L(u);
        }
    }
    
    update(u);
    
}

int main()
{
    memset(l,-1,sizeof(l));
    memset(r,-1,sizeof(r));
    
    int root = -1;
    cin >> n;
    int a;
    while(n --){
        cin >> a;
        insert(root,a);
    }
    
    cout << e[root] << endl;
    
    return 0;
}
遇见生活
关注
专栏目录
【每日一题】整数拆分
junxinsiwo的专栏
10-12 250
两个正整数的和，并使这些整数的乘积最大化。返回你可以获得的最大乘积。假设 f ( k ) 表示 n = k 时，获得的最大乘积。在尝试 0 到 n 所有可能性后，去最大值。i = 1 尝试 k - i 是否保留。
编程练习：快排划分整数数组(C语言版)
一颗胡萝卜的秘密基地
03-21 1315
设计一个函数，将整数数组a[n]划分为左右两部分，使左边所有元素值为奇数，右边所有值为偶数 #include<stdio.h> #include<math.h> #define N 6 int devide(int a[],int n) { int s,e,temp,k; s=0;//从左到右，起始坐标 e=n-1;//从右到左，起始坐标 while(s&...
整数划分（递归、动态规划、回溯）
m0_68536532的博客
06-09 2952
整数划分问题的递归、动态规划和回溯三种解法
Python编程练习：快排划分整数数组
一颗胡萝卜的秘密基地
03-21 346
设计一个函数，将整数数组a[n]划分为左右两部分，使左边所有元素值为奇数，右边所有值为偶数 def devide(xlist): l=len(xlist)#形参列表的长度 i=0 j=l-1 #快速排序法 while i<j: while xlist[i]%2!=0: i=i+1 while...
SDUT 3373 数据结构实验之查找一：二叉排序树
Code_KK的博客
12-03 3258
数据结构实验之查找一：二叉排序树 Time Limit: 400ms   Memory limit: 65536K  有疑问？点这里^_^ 题目描述 对应给定的一个序列可以唯一确定一棵二叉排序树。然而，一棵给定的二叉排序树却可以由多种不同的序列得到。例如分别按照序列{3,1,4}和{3,4,1}插入初始为空的二叉排序树，都得到一样的结果。你的任务书对于
作业5.html
最新发布
05-10
作业5.html
作业5.py
01-04
作业5.py
作业5.exe
11-21
作业5.exe
10-55 查询各专业学生的平均成绩
dqd66的博客
10-14 4703
分数 10全屏浏览题目切换布局作者 张庆单位 集美大学本题目要求编写SQL语句，统计各专业的学生选课的平均成绩，如果某专业尚未有任何学生选修课程或成绩为空时，平均分计为0。输出结果集按照major表中的mno升序排序。
c语言 分割整数 数组,C++将整数数组分割成奇数和偶数两个数组的代码
weixin_28738021的博客
05-21 2372
C++将整数数组分割成奇数和偶数两个数组的代码//get an array and by using it, create two different array which are odd and evenvoid arraySplitter(int *&array, int size, int &sizeEven, int &sizeOdd, int *&arr...
数组划分
suv1234的博客
06-01 290
给出一个整数数组 nums 和一个整数 k。划分数组（即移动数组 nums 中的元素），使得： 所有小于k的元素移到左边 所有大于等于k的元素移到右边 返回数组划分的位置，即数组中第一个位置 i，满足 nums[i] 大于等于 k。 public int partitionArray(int[] nums, int k) { //write your code here
递归特训：简单的整数划分（数组暂存优化）
mavises的博客
08-06 231
本题可以利用递归求解的思想。题目中要求将n个整数由1-n进行划分。这里可以计算更一般的的情况，可求得整数n由1-m划分的结果数量。先列出递归关系式: divide(n,m)=divide(n-m,m)+divide(n,m-1)       n&gt;=m //分为两类，划分过程取m和不取m。 divide(n,m)=divide(n,n)                           ...
数组划分 I
weixin_41791402的博客
08-18 252
给一个有2n个整数的数组，你的任务是把这些整数分成 n 组，如(a1, b1)，(a2, b2)，...，(an, bn)。并且使得 i 从 1 到 n 的 min(ai, bi)之和尽可能的大。 样例 样例1: 输入: [1,4,3,2] 输出: 4 解释: n 是 2, 最大的数对和为 4 = min(1, 2) + min(3, 4). 样例 2: 输入: [5,6] 输...
一个整数数组，长度为n，将其分为m 份，使各份的和相等，求m 的最大值 比如{3，2，4，3，6} 可以分成{3，2，4，3，6} m=1; {3,6}{2,4,3} m=2 {3,3}{2,4}{6
dongqifan的专栏
03-19 1216
public class max { static int testmax(int[] a){ int sum=0; int maxnum = 0; int[] aux = new int[a.length]; for(int i=0;i sum+=a[i]; } for(int m=2;m for(int i=0;i aux[i] = 0; } if(sum%m!
6-6 判断两棵二叉树是否同构（递归法）
qq_60245590的博客
06-10 615
判断两棵二叉树是否同构（递归法） 输入两行字符序列先序递归构建两棵二叉树。每个字符对应一个树节点，#表示空节点。 输出样例： 同构输入1，否则输入0。 题解：感觉在PTA上，这道题的测试样例是有错误的，当时学的时候同构二叉树要求结构相同且元素相同，下面是定义：两棵二叉树被称为同构二叉树，当且仅当它们具有相同的结构，即它们的节点位置和连接方式完全相同。换句话说，如果可以通过对其中一个树的节点进行一系列的左右子树交换（或不交换）操作，使得两棵树的节点位置和连接方式完全相同，那么它们就是同
6-3判断两棵树是否同构（递归法）分数20
m0_66198354的博客
06-01 768
函数接口定义： 裁判测试程序样例： 输入样例：输入两行字符序列先序递归构建两棵二叉树。每个字符对应一个树节点，#表示空格。 输出样例：同构输入1，否则输入0.
树 练习题2
weixin_60833644的博客
05-24 2556
练习题
games101作业5
07-01
games101作业5是一个有趣的编程作业，要求学生使用OpenGL编写一个基础的游戏框架。 首先，我们需要实现一个窗口和一个渲染器。窗口用来显示游戏画面，渲染器负责将图形渲染到窗口上。为了实现这两个功能，我们可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值