while双循环指针求两数组的交集

已于 2022-06-20 18:04:01 修改
阅读量263 收藏
点赞数
文章标签： c# 开发语言
于 2022-06-19 00:08:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/helldoger/article/details/125353470
版权
这段代码展示了C#中使用NumSharp库操作二维数组，包括遍历、形状获取及数组转换。同时，演示了C++中计算数组交集的函数以及遍历并匹配两个列表中具有相同属性的对象。此外，还涉及到C++指针的使用，包括指针的声明、类型转换以及数组指针的操作。
摘要由CSDN通过智能技术生成 
// See https://aka.ms/new-console-template for more information

using NumSharp;



//测试numsharp
int[,] ints = new int[2, 3] { { 1, 2, 3 }, { 4, 5, 6 } };

NDArray dArray2 = np.array(new int[,] { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } });

NDArray dArray1 = np.array(ints);

foreach (var item in dArray1)
{
    Console.WriteLine($"{item}");
}


//dArray1.ToArray();
int a = dArray1.size;
int[] b = dArray1.shape;
Console.WriteLine($"{dArray1[0][1]},{a},{b[0]},{b[1]}");

int[,] ints1 = new int[dArray1.shape[0], dArray1.shape[1]];

for (int i = 0; i < ints1.GetLength(0); i++)
{
    for (int j = 0; j < ints1.GetLength(1); j++)
    {
        ints1[i, j] = dArray1[i][j];
    }
}

for (int i = 0; i < ints1.GetLength(0); i++)
{
    for (int j = 0; j < ints1.GetLength(1); j++)
    {
        Console.WriteLine($"写入的值为：{ints1[i, j]}");
    }
}

//结果：
/*
 1
2
3
4
5
6
2,6,2,3
写入的值为：1
写入的值为：2
写入的值为：3
写入的值为：4
写入的值为：5
写入的值为：6
 */





float[] c = new float[] { 1, 2, 3, 4, 5 };
float[] d = new float[] { 2F,4F, 5F, 6F, 7F, 8F };

float s = 0;
float e = 0;
float[] floatSection(float[] firstList, float[] secondList)
{
    var res = new List<float>();
    // 如果有一个数组为空，直接返回交集数组为空
    if (firstList.Length == 0 || secondList.Length == 0)
        return res.ToArray();
    int i = 0, j = 0;

    // 两个数组同时遍历
    while (i < firstList.Length && j < secondList.Length)
    {
        // 取范围的起点中大值作为交集起点
        s = Math.Max(firstList[i], secondList[j]);
        // 取范围的终点中小值作为交集终点
        e = Math.Min(firstList[i], secondList[j]);
        //起点小于终点，加入结果
        if (s <= e) //交点
        {
            res.Add(s);
        }
        if (firstList[i] > secondList[j])
        {
            j++;
        }
        else
        {
            i++;
        }
    }
    return res.ToArray();
}

Console.WriteLine("=========交集============");
foreach (var item in floatSection(c, d))
{
    Console.WriteLine(item);
}






List<Student> students = new List<Student>
{
    new Student{Id = 1, Name = "aa",Score = "89"},
    new Student{Id = 2, Name = "bb",Score = "11"},
    new Student{Id = 3, Name = "ada",Score = "12"},
    new Student{Id = 4, Name = "cc",Score = "13"},
    new Student{Id = 5, Name = "ee",Score = "15"}
};
List<Room> rooms = new List<Room>
{
    new Room{Id = 1,RoomName = "vv",Score = "7"},
    new Room{Id = 2,RoomName = "zz",Score = "8"},
    new Room{Id = 3,RoomName = "bb",Score = "12"},
    new Room{Id = 4,RoomName = "nn",Score = "89"},
    new Room{Id = 5,RoomName = "ng",Score = "18"}
};

List<Student> stu1 = new List<Student>();
void test1()
{
    int i = 0;
    int j = 0;
    foreach (var item in students)
    {
        foreach (var item2 in rooms)
        {
            if (item.Score == item2.Score)
            {
                stu1.Add(item);
            }
        }
    }

    foreach (var item in stu1)
    {
        Console.WriteLine(item.Score);
    }
}
Console.WriteLine("=========遍历============");
test1();

public class Student
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Score { get; set; }
}

public class Room
{
    public int Id { get; set; }
    public string RoomName { get; set; }
    public string Score { get; set; }
}

结果

1
2
3
4
5
6
2,6,2,3
写入的值为：1
写入的值为：2
写入的值为：3
写入的值为：4
写入的值为：5
写入的值为：6
=========交集============
2
4
5
=========遍历============
89
12

c语言指针：

#include <stdio.h>
#include<string.h>
#include<stdlib.h>

struct Person
{
	char name[64];
	int age;
};

typedef struct Person_
{
	char name[64];
	int age;
} MyPerson;

//typedef struct  Person_ MyPerson; //别名
int* func()
{
	int a = 10; //栈上创建的变量
	return &a;
}

void Test01()
{
	int* p = func(); //执行func()就被释放了
	printf("%d\n", *p);
	printf("%d\n", *p);
}



int main()
{
	struct Person p1 = { "张三", 18 };
	MyPerson p2 = { "李四", 19 };

	/*char* p1, p2; //指针，字符型
	printf("p1的数据类型为 %s\n", typeid(p1).name());
	printf("p2的数据类型为 %s\n", typeid(p2).name());*/

	typedef char* PCHAR;

	PCHAR p3, p4; //定义了2个指针

	//printf("%d", p2.age);
	//E:\C++\C++全套课\02-阶段二 C高级编程\01-第一章 C高级\1-1 变量和内存分布 08

	/*
	1.代码区：存放函数体内的二进制代码，有操作系统管理。

	2.全局区：存放全局变量，静态变量以及常量。

	3.栈区：由编译器自动分配和释放，存放函数参数，局部变量等

	4.堆区：由程序员分配释放，若程序员未释放，则程序结束之后，编译器自动释放。
	*/
	printf("=================\n");
	Test01();
}

C++ 知识

// CPPTest1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include <iostream>
#include <cstdio>


int main1()
{
    short a = 10;
    int b = 10;
    short* p = &a;
    short** pp = &p;
    int* p1 = &b;
    p = &a;
    pp = &p;
    std::cout << "p的值是\n"<<std::endl;
    std::cout << p << std::endl;
    std::cout << "*p的值是\n" << std::endl;
    std::cout << *p << std::endl;
    std::cout << "pp的值是\n" << std::endl;
    std::cout << pp << std::endl;
    std::cout << "*pp的值是\n" << std::endl;
    std::cout << *pp << std::endl;
    std::cout << "**pp的值是\n" << std::endl;
    std::cout << **pp << std::endl;
    std::cout << "**pp的size是\n" << std::endl;
    std::cout << sizeof(**pp) << std::endl;

    std::cout << "pp的size是\n" << std::endl;
    std::cout << sizeof(pp) << std::endl;

    std::cout << "*p1的size是\n" << std::endl;
    std::cout << sizeof(*p1) << std::endl;
    std::cout << "p1的size是\n" << std::endl;
    std::cout << sizeof(p1) << std::endl;

    return 0;
}
/*
64位编译器

00000018D98FF554
*p的值是

10
pp的值是

00000018D98FF598
*pp的值是

00000018D98FF554
**pp的值是

10
**pp的size是

2
pp的size是

8
*p1的size是

4
p1的size是

8

*/

/*
32位编译器
0135F7B8
*p的值是

10
pp的值是

0135F7A0
*pp的值是

0135F7B8
**pp的值是

10
**pp的size是

2
pp的size是

4
*p1的size是

4
p1的size是

4
*/

// 运行程序: Ctrl + F5 或调试 >“开始执行(不调试)”菜单
// 调试程序: F5 或调试 >“开始调试”菜单

// 入门使用技巧: 
//   1. 使用解决方案资源管理器窗口添加/管理文件
//   2. 使用团队资源管理器窗口连接到源代码管理
//   3. 使用输出窗口查看生成输出和其他消息
//   4. 使用错误列表窗口查看错误
//   5. 转到“项目”>“添加新项”以创建新的代码文件，或转到“项目”>“添加现有项”以将现有代码文件添加到项目
//   6. 将来，若要再次打开此项目，请转到“文件”>“打开”>“项目”并选择 .sln 文件

int main2()
{
    int a = 0x01020304;
    char* p1 = (char*)&a; 
    short* p2 = (short*)&a;
    int* p3 = &a;

    //int* p4; //野指针 p4 指向地址不清楚 int* p4 = &a; p4的地址一定要是定义过的
    //*p4 = 6;
    void* p4 = (void*)&a; //万能

    printf("p1的值是: %x\n", *p1); //1
    printf("p2的值是: %x\n", *p2); //2
    printf("p3的值是: %x\n", *p3); //4
    //printf("p4的值是: %x\n", *p4); //4 报错
    //std::cout << "*p1的值是\n" << std::endl;
    //std::cout << *p3 << std::endl;

    printf("p1的地址是: %u\n", p1); //1
    printf("p2的地址是: %u\n", p2); //2
    printf("p3的地址是: %u\n", p3); //4
    printf("p4的地址是: %u\n", p4); //4

    printf("p1+1的地址是: %u\n", p1+1); //步长加1
    printf("p2+1的地址是: %u\n", p2+1); //步长加2
    printf("p3+1的地址是: %u\n", p3+1); //步长加4


    return 0;
}

/*
p1的值是: 4
p2的值是: 304
p3的值是: 1020304
p1的地址是: 1387264804
p2的地址是: 1387264804
p3的地址是: 1387264804
p1+1的地址是: 1387264805
p2+1的地址是: 1387264806
p3+1的地址是: 1387264808
*/

template<class T>
T func(T a, T b)
{
    return a + b;
}

void test03()
{
    int a = 3;
    double b = 3.3;
    //func<int>(a, b);
    std::cout << func<int>(a, b) << std::endl;
}

int myPlus(int a, int b)
{
    return a + b;
}

template<class T>
T myPlus2(T a, T b)
{
    return a + b;
}

void Test()
{
    int a = 10;
    int b = 20;
    char c = 'a';
    myPlus(a, c);
    //myPlus2(a, c); //报错，函数模板不能直接进行隐式转换
    myPlus2<int>(a, c); //如果隐式转换，必须加上参数列表/泛型
}

int main3()
{
    //const int a = 10;
    //a = 100; const不能修改
    // int* p = &a; c++不能

    //int a = 10;
    //int* p1 = &a;
    //int** p2 = &p1;
    //std::cout << **p2 << std::endl; //10

    int b[10] = {1,2,3,4,5,6,7,8,9,10};
    int* p3 = b; //等价于 = &b[0]; 首地址
    int* p4 = &b[0];

    std::cout << *p3 << std::endl; //1
    std::cout << *p4 << std::endl; //1

    int c[5] = { 1,2,3,4,5 };
    int* ptr = (int*)(&c + 1); //&c 整个数组的地址，c是c[0]的地址。 &c + 1 是c[5] 之后的未知地区
    int* ptr2 = (int*)(c + 1); //c+1是2的地址
    //*(a + 1)
    printf("======================\n");
    printf("%d,%d,%d \n", *(c + 1), *(ptr - 1),*(ptr2-1)); 
    //2,5,1
    //c 是c[0]的地址。
    //ptr-1 步长为1个int，刚好回到c数组的最后一个数字

    int a[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int* p = a;
    printf("======================\n");
    for (int i = 0; i < sizeof(a)/sizeof(a[0]); i++)
    {
        //printf("%d \n", a[i]);
        //printf("%d\n",*(p + i));
        printf("%d\n", p[i]); //p[i] = *(p+i)
    }

    printf("=========dsds=============\n");

    test03();
    return 0;
}

typedef struct node
{
    int data;
    struct node* next;
} Node;

int main()
{
    int a = 5;
    Node p1 = { 5 };

    // Node* p; 相当于野指针
    Node* p = &p1;
    p->data = 5;
    std::cout << p->data << std::endl;
    return 0;
}



//template<class T> //让编译器看到这句话后面紧跟的函数里有T，不要报错
//void mySwap(T& a, T& b)
//{
//    T tmp = a;
//    a = b;
//    b = tmp;
//}
潘诺西亚的火山
关注
三.双指针/链表/数组
01-08 581
面试题 16.06. 最小差 class Solution: def smallestDifference(self, a: List[int], b: List[int]) -> int: a.sort(); b.sort() i = j = 0 res = float('inf') while i < len(a) and j < len(b): res = min(res, abs(a
用C语言求并集和交集
qq_42099629的博客
07-07 7604
#include<stdio.h> #include<stdlib.h> struct node { int data; struct node*next; }; typedef struct node NODE; //主函数 int main() { NODE *head1,*head2,*head3,...
349. 两个数组的交集（集合 / 双指针实现）
woaichikaoya的博客
04-25 208
两种实现思路 第一个思路：将一数组add进不重复集合去重。然后用另一个数组挨个查找包含元素 如果查到就说明是交集 则把这个数记录下来 然后从集合中删掉这个数字。 第二个思路：首先将两组数排序 然后使用两个指针去维护这两组数。找到重复的数字后记录下来，然后如果再遇到重复的数字 先判断是否记录过，如果没记录 就记录这个数字。 第一种思路清晰 实现简单 但是速度慢 第二种略微复杂 但是速度快 import java.util.ArrayList; import java.util.Arrays; import.
python while循环和双层循环
weixin_34037515的博客
08-17 1699
#python中，while语句用于循环执行程序，即在某个条件下，循环执行某段程序，以处理需要重复处理的相同任务。#while是“当型”循环结构。i=1while i<=20:print(i,end=" ")i+=1 sum=0i=1while i<=100:sum+=ii+=1else:print("\n",sum) print("0+2+...+100=",sum)#从控制台录入一...
c语言指针求数组交集,c语言指针与数组的问题求解
weixin_39524439的博客
05-19 205
#include#include#defineMAX_LEN10#defineN150voidsortstring(char*ptr[],intn);voidswap(char*ptr1,char*ptr2);intmain(){inti,n;charname[N][MAX_LEN];char*pstr[N];printf("howmanycountries?:");...
while双重循环
m0_46391111的博客
03-21 2005
while双重循环 1、ul和li var str = “”; var i = 1; while (i < 6) { str += “”; var j = 1; while (j < 11) { str += “” + j + “*” + i + “=” + “”; j++; ...
两个数组交集（双指针）1
08-03
当`while`循环结束时，`result`向量包含了两个数组的交集，最后返回`result`即可。 这个算法的时间复杂度主要取决于排序的过程，通常为O(n log n)，其中n是两个数组中元素总数的最大值。空间复杂度是O(min(m, n))，...
JavaScript获取两个数组交集的方法
10-24
在while循环中，我们比较两个索引所指向的元素，如果它们相等，则将该元素添加到结果数组`result`中，并同时将两个索引各自向前移动一位。如果一个数组的索引已经移动到了数组的末尾，或者两个数组当前指向的元素不...
[ Python ]两个数组的交集II -暴力解法 排序双指针
丹的博客
04-27 386
题目： 暴力解法: 遍历数组A跟数组B比较,如果遇到相等的元素,就把数组B的值置空,然后跳出本次比较,继续下一次比较。实在没有比这更复杂的解法了。 class Solution: def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]: n1=len(nums1) n2...
数组双指针和数组窗口
hello_JeremyWang的博客
11-25 4634
0. 内容说明 最近在自己编写一些小的算法的时候，深感自己的算法过于臃肿。碰巧Datawhale在新的一期组队学习中组织了数据结构与算法的课程学习。于是就参加了，再次感谢Datawhale~~ 首先跟大家分享一下两个自己感觉比较好的学习资料，一个是 算法通关手册 ，也是Datawhale在本次组队学习中的学习资料；一个是B站上的视频 【北京大学】数据结构与算法Python版（完整版），老师讲的特别棒（也难得有Python版的数据结构课程，哈哈~）。 需要指出的是：本次博客的内容更像是对上述两个资料做的笔记
指针输出while循环问题
04-06
利用指针输出一串字符与利用指针输出链表节点值
数组（两个循环的使用）
weixin_45410447的博客
04-30 422
package javaindass; import java.util.Scanner; public class JavaIndAss { public static void main(String[] args) { System.out.println("Enter 4 Numbers: "); Scanner in =new Scanner(Sy...
两个while循环
09-28 2276
void func(){ int number =0; int x =4,y=3; int i=0,j=0,row =8,col =4; while(i<row){ j=0; while(j<col){ number +=
循环两个集合筛选交集和补集
Sadlay的博客
06-17 753
最近项目中在做人员的编辑过程中，由于人员和岗位是一对多关系，而权限绑定着岗位ID，不可以直接失效再做插入，需要对编辑后的岗位集合和数据库中原先的岗位集合根据组织编码需要去循环比对做判断。 假设A集合（编辑后的岗位集合），B集合（数据库中岗位集合）。 A没有，B有，删除 A有，B没有，新增 A和B都有，更新 public int[] updatePtPostList(String s...
while嵌套循环
weixin_42820509的博客
05-27 3067
while 嵌套循环 语法结构 while（）{ while（) { 语句 } } 练习： 要求 输出 10行 5列的星号“ * ” int n=1;//外循环变量 控制行 int m=1;//内循环变量 控制列 System.out.println("输出10行5列的“ * ” "); while(n<=10){ System.out.print("*"); whi...
C-指针运算
Wakatipu1734的博客
03-24 153
1、指针 +- 整数 2、指针 - 指针（指针 +指针没有意义，类似于日期+日期） 3、指针的关系运算 实例1： 实例2： int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; int* pStart = arr; int* pEnd = arr + 9; while (pStart <= pEnd) { printf("%d ", *pStart); pStart++; } printf("\n");...
第五天C进阶：用while和指针遍历数组；char *p[]；作用域
jieyannn的博客
09-13 1237
while(*s) { /*---省略其他内容---*/ s++; } *：间接运算符 对 *s进行求值，就可以得到指针s指向的字符 这样可以通过指针遍历数组 char *p[]={"ABC","123","x"} char *p[]比起单纯的多维数组，字符尾没有多余的空间，但是得准备一部分空间来储存指向这部分空间的指针数组。因此占用的字节数也不同。 即：p[0]指向"ABC"的开...
C++数组逆置while循环指针
最新发布
09-14
在C++中，如果你想要通过while循环和指针来逆序一个数组，可以使用两个指针，一个指向数组的开始（end - n），另一个指向数组的结束（end）。这里假设`n`是数组的长度： ```cpp #include void reverseArray(int ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

潘诺西亚的火山

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值