实验六、消息队列数组排序

已于 2022-03-12 11:38:58 修改
阅读量204 收藏 1
点赞数
文章标签： linux c++ 算法 unix
于 2022-01-09 16:06:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40925617/article/details/122394766
版权

结合lab5，使用消息队列实现一个数组排序系统。client端负责提交排序数组（int），server端输出排序结果。

>示例

>client端：

```
Enter the length of input array:
5
Enter the array need to be sorted:
3 2 8 4 16
```

>server端：

```
2 3 4 8 16
```

思路：

client首先输入字符串len，然后逐位逐位转成整形，传给server，告知数组长度，
使用getchar，一位一位输入，控制输入格式，忽略所有非数字输入，不传送非数字的字符，数字之间空格隔开，传给server

server一位一位转换为相应个数的数字，然后使用选择排序，排序输出
使用flag，判断数字中是否有0，有0，则退出循环

运行结果：

client端

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<linux/msg.h>
 
#define MAXMSG 512
#define MSGKEY 1314
struct my_msg   //消息队列结构体
{
	long int msg_type;
	int i;
	char text[MAXMSG];
}msg;

int main(int argc, char const *argv[]){
	    char buffer[MAXMSG];
		int msgid = msgget(MSGKEY, 0666|IPC_CREAT);

		printf("msgid = %d!\n",msgid);

		msg.msg_type = 3;

        int flag = 1;
        while(flag){
            memset(buffer,'\0',MAXMSG);
	    	printf("\nEnter the length of input array:");
	    	scanf("%s", buffer);
	    	strcpy(msg.text, buffer);
	    	msgsnd(msgid, &msg, sizeof(msg.text), IPC_NOWAIT);
	    	
	    	int len= 0;
	    	for(auto i = 0; i<strlen(buffer);i++){
	    	    len = len*10 +(buffer[i]-'0');
	    	}
	    	
            memset(buffer,'\0',MAXMSG);
	    	printf("Enter the array need to be sorted:\n");
	    	char c;
	    	for(int i = 0,j=0;i<=len;){ 	
	    	    c = getchar();
	    	    
	    	    if(i!=0&&c <'0'|| c > '9'){
	    	      	i++;
	    	      	if(i==len+1)break;	   	    
	    	        buffer[j++] = ' ';
	    	    }   
	    	   
	    	    
	    	    //is num 0 - 9
	    	    while(c <'0'|| c > '9'){
	    	        c = getchar();    
	    	    }	
	    	    
	    	    //0 exit
	    	    if(i == 0){
	    	        i++;
	    	        if(c == '0') flag = 0;
	    	    }
	    	    else if(buffer[j-1] == ' '&&c == '0') {
	    	        flag = 0;
	    	    }
	    	            
	    	    buffer[j++] = c; 	    
	    	}
	    	
	    	strcpy(msg.text, buffer);	
	    	msgsnd(msgid, &msg, sizeof(msg.text), IPC_NOWAIT);
	    	/*
	    	paixu 
	    	int a[MAXMSG]={0};
	    	for(int i = 0,j=0;i<len;){
		        while(msg.text[j]>='0'&&msg.text[j]<='9'){
		                a[i] = a[i]*10 + msg.text[j++]-'0';
		        }
		        i++;
		        j++;
		    }
		        
		        
		    for(int i = 1; i<len;i++){
		        int min = i-1;
		        for(int j = i;j<len;j++){
		           if(a[j]<a[min]) min = j;
		        } 
		        int temp = a[min];
		        a[min] = a[i-1];
		        a[i-1] = temp;
		    }

		    for(int i = 0; i<len;i++){
		        printf("%d\t",a[i]);
		    }  
		    */  
        }
       // TO-DO
	    msgctl(msgid, IPC_RMID, 0);
	  exit(0);
}

server端

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<linux/msg.h>
 
#define MAXMSG 512
#define MSGKEY 1314

struct my_msg   //消息队列结构体
{
	long int msg_type;
	int i;
	char text[MAXMSG];
}msg;

int main(int argc, char const *argv[]){
		int msgid = msgget(MSGKEY, 0666|IPC_CREAT);
		
		printf("msgid = %d!\n",msgid);
		
		msg.msg_type=3;
        int flag = 1;
        int a[MAXMSG]={0};
        int len = 0; 
        while(flag){
            memset(msg.text,'\0',MAXMSG);
            while(1){
                if(msgrcv(msgid, &msg, sizeof(msg.text), msg.msg_type, IPC_NOWAIT)>0){
                    len = 0;
                    printf("```\nlength of array:\t%s", msg.text);
                    for(int i = 0; msg.text[i]!='\0';i++){
                        len = len*10 + (msg.text[i]-'0');
                    }
                    break;
                }
            }
              
            printf("\nrecv message:");
                
            memset(msg.text,'\0',MAXMSG);
            while(1){         
		        if(msgrcv(msgid, &msg, sizeof(msg.text), msg.msg_type, IPC_NOWAIT)> 0){
		    	    printf("\t%s", msg.text);
		            for(int i = 0,j=0;i<len;){
		                a[i]=0;
		                while(msg.text[j]>='0'&&msg.text[j]<='9'){
		                    //0 exit
	    	                if(a[i] == 0 &&msg.text[j] == '0') {
	    	                    flag = 0;
	    	                }
		                    a[i] = a[i]*10 + msg.text[j++]-'0';
		                }
		                //printf("%d\t",a[i]);
		                i++;
		                j++;//skip space

		            }

		            //select sort
		            for(int i = 1; i<len;i++){
		                int min = i-1;
		                for(int j = i;j<len;j++){
		                    if(a[j]<a[min]) min = j;
		                } 
		                int temp = a[min];
		                a[min] = a[i-1];
		                a[i-1] = temp;
		            }
                
                    //print sort array
                    printf("\nsort array:\t");
		            for(int i = 0; i<len;i++){
		                printf("%d  ",a[i]);
		            }
		            printf("\n```\n\n");
		            break;
		        }	        
            }       
        }

        msgctl(msgid, IPC_RMID, 0);
        
		exit(0);
}

client2

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<linux/msg.h>
 
#define MAXMSG 512
#define MSGKEY 10
struct my_msg   //消息队列结构体
{
	long int msg_type;
	int i;
	char text[MAXMSG];
}msg;

int main(int argc, char const *argv[]){
		int msgid = msgget(MSGKEY, 0666|IPC_CREAT);
		msg.msg_type = 3;
        int flag = 1;
        while(flag){
            memset(msg.text,'\0',MAXMSG);
	    	printf("\nEnter the length of input array:\n");
	    	scanf("%s", msg.text);
	    	msgsnd(msgid, &msg, sizeof(msg.text), IPC_NOWAIT);
	    	
	    	int len= 0;
	    	for(auto i = 0; i<strlen(msg.text);i++){
	    	    len = len*10 +(msg.text[i]-'0');
	    	}
	    	
            memset(msg.text,'\0',MAXMSG);
	    	printf("Enter the array need to be sorted:\n");
	    	char c[MAXMSG];
	    	for(int i = 0,k=0,j=0;i<len;i++){ 	
	    	    scanf("%s",c);
	    	    if(c[0]=='0'){//num is 0 
	    	        flag = 0;
	    	    }
	    	    
	    	    //copy
	    	    for(int j = 0;j<strlen(c);){ 	
                    msg.text[k++] = c[j++];	  
                }
                msg.text[k++] = ' ';//add space
	    	}	
	    	msgsnd(msgid, &msg, sizeof(msg.text), IPC_NOWAIT);
        }
	    msgctl(msgid, IPC_RMID, 0);
	    exit(0);
}

server2

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<unistd.h>
#include<sys/types.h>
#include<linux/msg.h>
 
#define MAXMSG 512
#define MSGKEY 10

struct my_msg   //消息队列结构体
{
	long int msg_type;
	int i;
	char text[MAXMSG];
}msg;

int main(int argc, char const *argv[]){
		int msgid = msgget(MSGKEY, 0666|IPC_CREAT);	
		msg.msg_type=3;
        int flag = 1;
        int a[MAXMSG]={0};
        int len = 0; 
        while(flag){
            memset(msg.text,'\0',MAXMSG);
            while(1){
                if(msgrcv(msgid, &msg, sizeof(msg.text), msg.msg_type, IPC_NOWAIT)>0){
                    len = 0;
                    for(int i = 0; msg.text[i]!='\0';i++){
                        len = len*10 + (msg.text[i]-'0');
                    }
                    break;
                }
            }
                
            memset(msg.text,'\0',MAXMSG);
            while(1){         
		        if(msgrcv(msgid, &msg, sizeof(msg.text), msg.msg_type, IPC_NOWAIT)> 0){
		            //printf("%s\n",msg.text);
		            for(int i = 0,j=0;i<len;){
		                a[i]=0;
		                while(msg.text[j]>='0'&&msg.text[j]<='9'){
	    	                if(a[i] == 0 &&msg.text[j] == '0') {
	    	                    flag = 0;
	    	                }
		                    a[i] = a[i]*10 + msg.text[j++]-'0';
		                }
		                //printf("%d\t",a[i]);
		                i++;
		                j++;//skip space

		            }
		            
		            //bubble sort
		            for(int i = 1; i<len;i++){
		                for(int j = 0;j<len-i;j++){
		                    if(a[j]>a[j+1]){
		                    	int temp = a[j];
		                        a[j] = a[j+1];
		                        a[j+1] = temp;
		                    }
		                }
		            }
                    printf("\n```\n");
                    //print sort array
		            for(int i = 0; i<len;i++){
		                printf("%d  ",a[i]);
		            }
		            printf("\n```\n");
		            break;
		        }	        
            }       
        }

        msgctl(msgid, IPC_RMID, 0);
        
		exit(0);
}

稳健的不高冷的强哥
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
MQ消息队列的消息排序与优先级
禅与计算机程序设计艺术
02-22 201
1. 背景介绍 1.1 消息队列简介 消息队列（Message Queue，简称MQ）是一种应用程序间的通信方法，它允许应用程序通过消息的形式进行异步通信。消息队列的主要优点是解耦、可扩展性、容错性和异步性。在分布式系统中，消息队列被广泛应用于实现服务之间的解耦和通信。
数据结构实验报告+代码（链表 二叉树 图 字符串 数组 排序 队列 栈）
01-25
这份"数据结构实验报告+代码"涵盖了多个关键的数据结构类型，包括链表、二叉树、图、字符串、数组、排序、队列和栈。下面我们将详细探讨这些知识点。 1. **链表**：链表是一种线性数据结构，其中元素不是在物理内存...
顺序消息队列
DouJiangMs的博客
09-21 1060
消息队列顺序具体分为局部有序和全局有序：局部顺序：一个Topic下只需要满足同一消息key是有序的既可。例如，一个Topic下是内容变更流水，消息key值为内容ID，同一个内容ID下所有的消息是有序的；全局有序：一个Topic下的所有消息都要有序。
Android消息机制 异步消息 & 消息队列排序
kc58236582的博客
11-08 2943
之前消息机制的原理都已经分析过了，不过对java层的消息队列的排序和异步没有详细讲过。 一、消息队列排序 一般的像我们普通调用Handler发送消息，最后都会调用MessageQueue的enqueueMessage。 public boolean sendMessageAtTime(Message msg, long uptimeMillis) { Mess
消息队列中，如何保证消息的顺序性？
刘翼荣的博客
02-21 272
文章目录消息队列中，如何保证消息的顺序性？解决方案RabbitMQKafka 消息队列中，如何保证消息的顺序性？ 解决方案 RabbitMQ 拆分多个 queue，每个 queue 一个 consumer，就是多一些 queue 而已，确实是麻烦点；或者就一个 queue 但是对应一个 consumer，然后这个 consumer 内部用内存队列做排队，然后分发给底层不同的 worker 来处理。 Kafka 一个 topic，一个 partition，一个 consumer，内部单线程消费，单线程吞吐量
c语言优先队列对数组的排序,优先队列+sort+栈+队列讲解
weixin_39858124的博客
05-22 348
队列我们都知道，是一种先进后出的数据结构。队列的基本操作http://blog.csdn.net/qq_32680617/article/details/50822430而优先队列是把队列内部的数据，按照一定的优先级排序后，再输出。值得注意的是，优先队列没有front和back，只有top一种输出方式，这一点很像栈。栈的基本操作http://blog.csdn.net/qq_32680617/ar...
队列冒泡排序VI
10-17
1. 创建一个队列，将待排序的数组元素逐个入队。 2. 使用冒泡排序的逻辑，但每次不是直接操作数组，而是通过队列来实现。例如，可以出队两个元素，比较它们的大小，然后根据需要重新入队。 3. 这个过程反复进行，...
实验5-排序方法1
08-03
实验5的焦点在于排序方法的实现与比较，主要涉及了三种不同的排序算法组合：冒泡排序与快速排序、插入排序与希尔排序、选择排序与堆排序。这些算法都是计算机科学中基础且重要的数据处理技术。 首先，让我们逐一...
用单链表和队列实现归并排序
06-30
在标题“用单链表和队列实现归并排序”中，我们可以理解到这个实现是利用了链表和队列的数据结构。链表是一种线性数据结构，其中的元素在内存中不是顺序存储的，而是通过指针链接。队列则是一种先进先出（FIFO）的...
实验4 队列.zip
05-23
1. **数组实现**：使用固定大小的数组，当队列满时无法再进行入队操作，称为“环形队列”。 2. **链表实现**：每个节点包含元素和指向下一个节点的指针，灵活且无需预先设定容量。 3. **双端队列（Deque）**：允许在...
进程间通信——消息队列，共享内存，信号量数组
qq_43008645的博客
04-13 329
命令：ipcs 查看共享内存、消息队列、信号量数组使用情况 ipcrm:删除 共享内存、消息队列、信号量数组 大写（根据指定的KEY删除） 小写（根据指定的id删除） -M -Q -S -m -q -s 三种通信方式键值KEY获取： ftok()函数：key_t ftok(const char *pathname, int proj_id); xxxget xxxopt xxxctl
c/c++ 消息队列(循环数组实现)
yuanshenqiang的博客
12-09 1016
typedef struct _tagFIFO_QUE { void* cycleQue;//队列的起始地址 long long front;//队列的头偏移 long long rear;//队列的尾偏移 unsigned long dataSize;//元素的大小 unsigned long maxLen;//元素的个数*元素的大小 }FIFO_QUE, *LPFIFO_QUE; static bool IsQueEmpty(LPFIFO_QUE que) {.
消息队列（message queue）
最新发布
weixin_56409008的博客
02-14 306
消息队列简介
队列（一）——队列的数组实现方式
laoniu_c的专栏
08-04 5839
1.队列的概念 队列是一种特殊的线性表，只允许在队列的一端进行插入而在另一端进行删除。 队列一般拥有队首（front指针）和队尾（rear指针），当一个队列并未存入数据的时候，front和rear指针均指向队首。 入队的操作：rear后移，存入数据在rear指向的单元，队满不可入队，这同时也表明front总是指向队首元素的前驱。 出队的操作：front后移，元素出队，队空不可出队。 注意
int main(int argc, const char *argv[])
qq_43270406的博客
03-01 5150
int main(int argc, const char *argv[]) argc是命令行总的参数个数 argv[]为保存命令行参数的字符串指针，其中第0个参数是程序的全名，以后的参数为命令行后面跟的用户输入的参数，argv参数是字符串指针数组，其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。 指针数组的长度即为参数个数argc。数组元素初值由系统自动赋予。 int main(int argc, const char *argv[]) { if(5 > argc) { printf(“
int main(int argc, const char * argv[])
努力的小白马
05-19 2383
int main(int argc, const char * argv[])是UNIX和linux中的标准写法。int main（）只是默许的用法。   我们经常用的main函数都是不带参数的。因此main 后的括号都是空括号。实际上，main函数可以带参数，这个参数可以认为是 main函数的形式参数。Ｃ语言规定main函数的参数只能有两个，习惯上这两个参数写为argc和argv。因此，main函数的函数头可写为： main (argc,argv)，Ｃ语言还规定argc(第一个形参)必须是整型变量,arg
今天的Linux实验
qq_52809135的博客
11-28 114
【代码】今天的Linux实验。
int main(int argc,char** argv)
haomingzidoumeilea的专栏
03-29 4217
http://bbs.csdn.net/topics/210046601 给你贴段话，仔细看看就明白了 ｍａｉｎ函数的参数 　　前面介绍的main函数都是不带参数的。因此main 后的括号都是空括号。实际上，main函数可以带参数，这个参数可以认为是 main函数的形式参数。Ｃ语言规定main函数的参数只能有两个， 习惯上这两个参数写为argc和argv。因此，main函数的函数头可写为
FreeRTOS — 消息队列
热门推荐
流风回雪的博客
04-20 1万+
以下内容转载自安富莱电子：http://forum.armfly.com/forum.phpFreeRTOS 的一个重要的通信机制----消息队列，消息队列在实际项目中应用较多。1、消息队列 1.1 消息队列的概念及其作用　　消息队列就是通过 RTOS 内核提供的服务，任务或中断服务子程序可以将一个消息（注意，FreeRTOS消息队列传递的是实际数据，并不是数据地址，RTX，uCOS-II 和 u...
数据结构实验：FILO、循环队列、排序与DP
3. **排序算法**：实验涵盖了两种经典的排序算法——归并排序和快速排序。归并排序是分治策略的典型应用，通过递归地将数组分为两半，然后合并已排序的子数组。快速排序则采用“分区-递归”策略，选取一个基准元素，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值