分类： 未分类

#define _CRT_SECURE_NO_WARNINGS /* VS2013,2015需要这一行 */
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "osapi/osapi.h"


OS_Mutex g_mutex;
int g_buf[100]; // 缓冲区：最多存放100个数
int g_count = 0;

OS_Semaphore g_sem(0);

// 第一个线程：生产者
class Producer : public OS_Thread
{
public:
    int Routine()
    {
        while(1)
        {
            int r = rand() % 20 + 1; // 生成一个1..20之间的随机数
            OS_Thread::Msleep(50 * r); // 睡觉的间隔50-1000毫秒

            // 存放一个物品(这里就是存一个数, 代表一下物品的意思)
            g_mutex.Lock();
            g_buf[g_count] = r;
            g_count ++;
            printf("放入物品: %d \n", r);
            g_mutex.Unlock();

            g_sem.Post(); // 把信号量的值加1
        }
        return 0;
    }
};

// 第二个线程：消费者
class Consumer : public OS_Thread
{
public:
    int Routine()
    {
        // 轮询机制：频繁查询当前物品的个数
        while(1)
        {
            //OS_Thread::Msleep(800); // 信号量机制不用sleep
            g_sem.Wait(); // 信号量减1

            g_mutex.Lock();
            if(g_count > 0)
            {
                for(int i=0; i<g_count; i++)
                {
                    printf(" ==== 消费物品: %d \n", g_buf[i]);
                }
                g_count = 0;
            }
            g_mutex.Unlock();
        }
        return 0;
    }
};

int main()
{
    srand(time(NULL));

    // 启动第一个线程
    Producer p;
    p.Run();

    // 启动第二个线程
    Consumer c;
    c.Run();

    // 按回车退出程序
    getchar();
    return 0;
}

 

#define _CRT_SECURE_NO_WARNINGS /* VS2013,2015需要这一行 */
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include "osapi/osapi.h"


OS_Mutex g_mutex;
int g_buf[100]; // 缓冲区：最多存放100个数
int g_count = 0;

// 第一个线程：生产者
class Producer : public OS_Thread
{
public:
    int Routine()
    {
        while(1)
        {
            int r = rand() % 20 + 1; // 生成一个1..20之间的随机数
            OS_Thread::Msleep(50 * r); // 睡觉的间隔50-1000毫秒

            // 存放一个物品(这里就是存一个数, 代表一下物品的意思)
            g_mutex.Lock();
            g_buf[g_count] = r;
            g_count ++;
            printf("放入物品: %d \n", r);
            g_mutex.Unlock();
        }
        return 0;
    }
};

// 第二个线程：消费者
class Consumer : public OS_Thread
{
public:
    int Routine()
    {
        // 轮询机制：频繁查询当前物品的个数
        while(1)
        {
            OS_Thread::Msleep(800);

            g_mutex.Lock();
            if(g_count > 0)
            {
                for(int i=0; i<g_count; i++)
                {
                    printf(" ==== 消费物品: %d \n", g_buf[i]);
                }
                g_count = 0;
            }
            g_mutex.Unlock();
        }
        return 0;
    }
};

int main()
{
    srand(time(NULL));

    // 启动第一个线程
    Producer p;
    p.Run();

    // 启动第二个线程
    Consumer c;
    c.Run();

    // 按回车退出程序
    getchar();
    return 0;
}

 

#define _CRT_SECURE_NO_WARNINGS /* VS2013,2015需要这一行 */
#include <stdio.h>

#include "osapi/osapi.h"

OS_Mutex g_mutex;
char g_key[16]; // Generator更新它，Checker获取它

class KeyGenerator : public OS_Thread
{
private:
    virtual int Routine()
    {
        int times = 0;
        while(1)
        {
            // 生成key: 需要80ms
            char key_new[16];			
            for(int i=0; i<16; i++)
            {
                OS_Thread::Msleep(5);
                key_new[i] = times;
            }

            // 更新key: 占有锁的时间非常短
            g_mutex.Lock();
            memcpy(g_key, key_new, 16);
            g_mutex.Unlock();

            times ++;
            if(times >= 128) times = 0;
            //OS_Thread::Msleep(50);
        }
        return 0; 
    }
};

class KeyChecker : public OS_Thread
{
private:
    // 线程主函数
    virtual int Routine()
    {
        while(1)
        {		
            // 尽量缩短对共享数据的访问时间
            char copy[16];
            g_mutex.Lock();
            memcpy(copy, g_key, 16);
            g_mutex.Unlock();

            // 数据处理
            // 检查完整性			
            for(int i=1; i<16; i++)
            {
                if(copy[i] != copy[i-1])
                {
                    printf("不完整!!\n");
                    PrintKey();
                    //return 0;
                }
            }			

            //OS_Thread::Msleep(50);
        }
        return 0; // 正常退出
    }

    void PrintKey()
    {
        printf("Key: ");
        for(int i=0; i<16; i++)
            printf("%02X ", g_key[i]);					
        printf("\n");
    }
};


int main()
{
    KeyGenerator a;
    a.Run();

    KeyChecker b;
    b.Run();

    getchar();


    return 0;
}

 

#define _CRT_SECURE_NO_WARNINGS /* VS2013,2015需要这一行 */
#include <stdio.h>

#include "osapi/osapi.h"

// 定义一个类
class Buddhist : public OS_Thread
{
public:
    int Start()
    {
        // 其他准备工作
        m_quitflag = false;
        Run();
        return 0;
    }

    void Stop()
    {
        m_quitflag = true;
        Join(this);
    }

private:
    // 线程主函数
    virtual int Routine()
    {
        // 线程体: 执行它的任务
        for(int i=0; !m_quitflag && i<100; i++)
        {
            printf("ma mi ma mi hong ...\n");
            OS_Thread::Sleep(1);
        }
        printf("Task Exit.\n");
        //  保存数据，善后工作
        printf("善后工作...\n");
        return 0; // 正常退出
    }

private:
    bool m_quitflag;

};

int main()
{
    Buddhist  task1;
    task1.Start();

    getchar();
    task1.Stop();

    return 0;
}

 

#define _CRT_SECURE_NO_WARNINGS /* VS2013,2015需要这一行 */
#include <stdio.h>

#include "osapi/osapi.h"

// 定义一个类
class Buddhist : public OS_Thread
{
private:
    virtual int Routine()
    {
        // 线程体: 执行它的任务
        for(int i=0; i<100; i++)
        {
            printf("ma mi ma mi hong ...\n");
            OS_Thread::Sleep(1);
        }
        return 0;
    }
};

class Confucian : public OS_Thread
{
private:
    virtual int Routine()
    {
        for(int i=0; i<500; i++)
        {
            printf("人之初，性本善 ...\n");
            OS_Thread::Sleep(1);
        }
        return 0;
    }
};
int main()
{
    Buddhist  task1;
    task1.Run();

    Confucian  task2;
    task2.Run();

    // 
    printf("--------- 主线程开始 -------\n");
    for(int i=0; i<10; i++)
    {
        printf("********* \n");
        OS_Thread::Sleep(1);
    }

    getchar();

    return 0;
}

 

Input

第 1 行：整数 n (1≤n≤10)

第 2 行 ~ n+1 行：每行是个数范围为 1 ~ 120 的一组字符。一组字符中可能包含空格、制表符、汉字、字母、数字、标点符号。

Output

对于每一行中的一组字符，以最简分数形式在一行中输出其数据密度。

分数格式：分子 / 分母

#include <stdio.h>
#include <string.h>
void solve(char *s);
int gcd(int a, int b){
    return a ? gcd(b % a, a) : b ;
}

int main ()
{
    int T;
    scanf("%d", &T);
    while(T--){
        char s[121];
        gets(s);
        solve(s);
        return 0; 
    }
}

void solve(char *s)
{
    int s1  = 0, bytes=strlen(s), i, j;
    for (int i = 0; i < bytes; i++){
        unsigned char c= s[i]; //为了使用逻辑右移，定义为无符号字符类型
        for (j = 0; j < 8; j++){
            s1 += c % 2; //统计1的位数
            c>>=1; //逻辑右移
        }
    }
    int g = gcd(s1, bytes * 8);//最大公约数
    printf ("%d/%d", s1/g, bytes * 8 / g);

}

 

先说明一下qsort和sort，只能对连续内存的数据进行排序，像链表这样的结构是无法排序的。

首先说一下， qsort
qsort（基本快速排序的方法，每次把数组分成两部分和中间的一个划分值，而对于有多个重复值的数组来说，基本快速排序的效率较低，且不稳定）。集成在C语言库函数里面的的qsort函数，使用 三 路划分的方法解决排序这个问题。所谓三路划分，是指把数组划分成小于划分值，等于划分值和大于划分值的三个部分。

具体介绍：-^^

void qsort( void *base, size_t num, size_t width, int (__cdecl *compare )
int compare (const void *elem1, const void *elem2 ) );

qsort（即，quicksort）主要根据你给的比较条件给一个快速排序，主要是通过指针移动实现排序功能。排序之后的结果仍然放在原来数组中。
参数意义如下:
第一个参数 base 是 需要排序的目标数组名（或者也可以理解成开始排序的地址，因为可以写&s[i]这样的表达式）
第二个参数 num 是 参与排序的目标数组元素个数
第三个参数 width 是单个元素的大小（或者目标数组中每一个元素长度），推荐使用sizeof(s[0]）这样的表达式
第四个参数 compare 就是让很多人觉得非常困惑的比较函数啦。

我们来简单讨论compare这个比较函数（写成compare是我的个人喜好，你可以随便写成什么，比如 cmp 什么的，在后面我会一直用cmp做解释）。 典型的compare的定义是int compare(const void *a,const void *b);
返回值必须是int，两个参数的类型必须都是const void *，那个a,b是随便写的，个人喜好。假设是对int排序的话，如果是升序，那么就是如果a比b大返回一个正值，小则负值，相等返回0，其他的依次类推，后面有例子来说明对不同的类型如何进行排序。

qsort 的使用方法：

一、对int类型数组排序

int num[100];

int cmp ( const void *a , const void *b )

{

  return *(int *)a - *(int *)b;  //升序排序

//return *(int *)b - *(int *)a; //降序排序

/*可见：参数列表是两个空指针，现在他要去指向你的数组元素。所以转型为你当前的类型，然后取值。
        升序排列时，若第一个参数指针指向的“值”大于第二个参数指针指向的“值”，则返回正；若第一个参数指针指向的“值”等于第二个参数指针指向的“值”，则返回零；若第一个参数指针指向的“值”小于第二个参数指针指向的“值”，则返回负。
        降序排列时，则刚好相反。

*/

}

qsort(s,n,sizeof(s[0]),cmp);

//示例完整函数（已在 VC6.0上运行通过）：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int s[10000],n,i;
int cmp(const void *a,const void *b)
{
return(*(int *)b-*(int *)a);  //实现的是升序排序
}
int main()
{

// 输入想要输入的数的个数
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d",&s[i]);
qsort(s,n,sizeof(s[0]),cmp);
for(i=0;i<n;i++)
printf("%d ",s[i]);
return(0);
}

再说说 sort （常用于 C++ ）

sort 使用时得注明：using namespace std; 或直接打 std::sort() 还得加上 #include <algorithm> 头文件

//例：

#include<iostream>
#include<algorithm>
using namespace std;



int main()
{
       int a[20];
　　 for(int i=0;i<20;++i)
              cin>>a[i];
   　 sort(a,a+20);             //范围，很明显这里是a+20 注意，这是必要的，如果是a+19
       for(i=0;i<20;i++)        //最后一个值a[19]就不会参与排序。
              cout<<a[i]<<endl;
       return 0;

}

std::sort是一个改进版的qsort. std::sort函数优于qsort的一些特点：对大数组采取9项取样，更完全的三路划分算法，更细致的对不同数组大小采用不同方法排序。

最后，我们来说说sort、qsort的区别：
sort是qsort的升级版，如果能用sort尽量用sort，使用也比较简单，不像qsort还得自己去写 cmp 函数，只要注明 使用的库函数就可以使用，参数只有两个（如果是普通用法）头指针和尾指针；

默认sort排序后是升序，如果想让他降序排列，可以使用自己编的cmp函数

#include<iostream>
#include<algorithm>
using namespace std;
int cmp(int a,int b)
{
  if(a<b)
  return 1; //升序排列，如果改为 a >b，则为降序,要注意sort()中cmp()的返值只有1和0，不像qsort中存在－1！！！！
  else
  return 0;
}


int main(){
    int i;
 int a[20];
 for(int i=0;i<5;++i)
  cin>>a[i];

sort(a,a+5,cmp);          //范围，很明显这里是a+5 注意，这是必要的，如果是a+4最后一个值a[4]就不会参与排序。
for(i=0;i<5;i++)       

cout<<a[i]<<endl;
    system("pause");
 return 0;
}

 

对二维数组的排序：
#include <iostream>
#include <algorithm>
#include <ctime>
using namespace std;

bool cmp(int *p,int *q)
{
    if(p[0]==q[0])
    {
        if(p[1]==q[1])
        {
            return p[2]<q[2];
        }
        else return p[1]<q[1];
    }
    else return p[0]<q[0];
}
int main()
{
    srand(time(0));
    int i;
    int **a=new int*[1000];
    for(i=0;i<1000;++i)
    {
        a[i]=new int[3];
        a[i][0]=rand()%1000;
        a[i][1]=rand()%1000;
        a[i][2]=rand()%1000;
        //printf("%d\t%d\t%d\n",a[i][0],a[i][1],a[i][2]);
    }
    sort(a,a+1000,cmp);
    /*cout<<"After sort"<<endl;
    for(i=0;i<1000;++i)
    {
        printf("%d\t%d\t%d\n",a[i][0],a[i][1],a[i][2]);
    }*/
    return 0;
}