c算法csdn

❶ c语言中十进制和二进制怎么转换

10000101 对于这个来说 一般 最高位 为 符号位 0为+， 1为- 所以为 -5；short类型占2个字节，也就是 16位， 最大值为0111 1111 1111 1111。 进制之间的 转换，比如 10进制92 转换成 2进制，92/2 = 46 余数是 0,46/2 = 23 余数是 0，23/2 = 11 余数是 1， 11/2 = 5, 余数是1， 5/2 = 2，余数是 1， 2/2 = 1， 余数是 0， 所以2进制为 0111100（这里面的余数是从后往前计的）。

❷ 在C语言中，如何输出一组数的排列组合

#include <stdio.h>

#include <stdlib.h>

int n = 0;

void swap(int *a, int *b)

{

int m;

m = *a;

*a = *b;

*b = m;

}

void perm(int list[], int k, int m)

{

int i;

if(k > m)

{

for(i = 0; i <= m; i++)

printf("%d ", list[i]);

printf(" ");

n++;

}

else

{

for(i = k; i <= m; i++)

{

swap(&list[k], &list[i]);

perm(list, k + 1, m);

swap(&list[k], &list[i]);

}

}

}

int main()

{

int k;//输入自然数的个数

printf("请输入连续自然数的个数：");

scanf("%d",&k);

int *list = (int *)malloc(k);

for (int i = 0; i < k; i ++)

{

list[i] = i + 1;

}

// int list[] = {1, 2, 3, 4, 5};

perm(list, 0, k-1);

printf("total:%d ", n);

return 0;

}

该程序的输入为一个任意自然数n，将输出从1到n的全排列。

(2)c算法csdn扩展阅读：

C语言的基本数的排列法

1、冒泡排序：每次相邻两个数比较,若升序,则将大的数放到后面,一次循环过后，就会将最大的数放在最后。

#include <stdio.h>

int main(void)

{

int a[1001];

int n,i,j,t;

scanf("%d",&n);//n为要排序的数的个数

//输入要排序的数

for(i=0;i<n;++i)

scanf("%d",a+i);

//接下来进行排序

for(i=0;i<n-1;++i)//n个数,总共需要进行n-1次

{ //n-1个数排完,第一个数一定已经归位

//每次会将最大(升序)或最小(降序)放到最后面

for(j=0;j<n-i-1;++j)

{

if(a[j]>a[j+1])//每次冒泡,进行交换

{

t=a[j];

a[j]=a[j+1];

a[j+1]=t;

}

}

for(j=0;j<n;++j)

printf("%-5d ",a[j]);

printf(" ");

}

return 0;

}

2、选择排序：从第一个数开始,每次和后面剩余的数进行比较,若升序,则如果后边的数比当前数字小,进行交换,和后面的所有的数比较、交换后,就会将当前的最小值放在当前的位置。

#include <stdio.h>

int main(void)

{

int a[1001];

int n,i,j,t;

scanf("%d",&n);//n为要排序的数的个数

//输入需要排序的数

for(i=0;i<n;++i)

scanf("%d",a+i);

//接下来进行排序

for(i=0;i<n-1;++i)//因为每次需要和a[i]后面的数进行比较,所以到a[n-2](倒数第2个元素)就行

{

for(j=i+1;j<n;++j)//j从i后一个开始,a[i]与a[j]进行比较

{

if(a[i]>a[j])//a[i]为当前值,若是比后面的a[j]大,进行交换

{

t=a[i];

a[i]=a[j];

a[j]=t;

}

}//每排序一次,就会将a[i](包括a[i])之后的最小值放在a[i]的位置

for(j=0;j<n;++j)

printf("%-5d",a[j]);

printf(" ");

}

return 0;

}

❸ C语言中算数运算符,关系运算符,逻辑运算符的优先级别

1级优先级（左结合）
() 圆括号；[]下标运算符；->指向结构体成员运算符；. 结构体成员运算符。
2级优先级（右结合）
!逻辑非运算符；~按位取反运算符；++前缀增量运算符；--前缀减量运算符；+正号运算符；-负号运算符；(类型)类型转换运算符；*指针运算符；&地址运算符；sizeof长度运算符。
3级优先级（左结合）
*乘法运算符；/除法运算符；%取余运算符。
4级优先级（左结合）
+加法运算符；-减法运算符。
5级优先级（左结合）
<<左移运算符；>>右移运算符。
6级优先级（左结合）
<、<=、>、>=关系运算符。
7级优先级（左结合）
==等于运算符；!=不等于运算符。
8级优先级（左结合）
&按位与运算符。
9级优先级（左结合）
^按位异或运算符。
10级优先级（左结合）
|按位或运算符。
11级优先级（左结合）
&&逻辑与运算符。
12级优先级（左结合）
||逻辑或运算符。
13级优先级（右结合）
? :条件运算符。
14级优先级（右结合）
=、 +=、 -=、 *=、 /=、 %=、 &=、 ^=、 |=、 <<=、 >>=赋值运算符。
15级优先级（左结合）
,逗号运算符。

❹ 我初学C语言，对C不是很了解，哪位高手可以告诉我一些学习方法，经验，万分感激

自己博客上的文章
很多人对学习C语言感到无从下手，经常问我同一个问题：究竟怎样学习C语言？我是一个教师，已经开发了很多年的程序，和很多刚刚起步的人一样，学习的第一个计算机语言就是C语言。经过这些年的开发，我深深的体会到C语言对于一个程序设计人员多么的重要，如果不懂C语言，你想写底层程序这几乎听起来很可笑，不懂C语言，你想写出优秀高效的程序，这简直就是天方夜谭。为什么C语言如此重要呢？

第一:C语言语法结构很简洁精妙，写出的程序也很高效，很便于描述算法，大多数的程序员愿意使用C语言去描述算法本身，所以，如果你想在程序设计方面有所建树，就必须去学它。
第二：C语言能够让你深入系统底层，你知道的操作系统，哪一个不是C语言写的？所有的windows,Unix,Linux,Mac,os/2，没有一个里外的，如果你不懂C语言，怎么可能深入到这些操作系统当中去呢？更不要说你去写它们的内核程序了。
第三：很多新型的语言都是衍生自C语言，C++,Java,C#,J#,perl...哪个不是呢？掌握了C语言，可以说你就掌握了很多门语言，经过简单的学习，你就可以用这些新型的语言去开发了，这个再一次验证了C语言是程序设计的重要基础。还有啊，多说一点：即使现在招聘程序员，考试都是考C语言，你想加入it行业，那么就一定要掌握好C语言。

那么究竟怎样学习C语言呢？

1:工欲善其事，必先利其器
这里介绍几个学习C语言必备的东东：
一个开发环境，例如turbo?C?2.0,这个曾经占据了DOS时代开发程序的大半个江山。但是现在windows时代，用turbo?C有感觉不方面，编辑程序起来很吃力，并且拖放，更没有函数变量自动感应功能，查询参考资料也不方便。建议使用Visual C++,这个东西虽然比较大块头，但是一旦安装好了，用起来很方便。

一本学习教程,现在C语言教材多如牛毛，但推荐大家使用《C语言程序设计》谭浩强主编 第二版 清华大学出版社，此书编写的很适合初学者，并且内容也很精到。

除此以外，现在有很多辅助学习的软件，毕竟现在是Window时代了，学习软件多如牛毛，不象我们当初学习，只有读书做题这么老套。我向大家推荐一个“集成学习环境(C语言)”，里边的知识点总结和例程讲解都非常好，还有题库测试环境，据说有好几千题，甚至还有一个windows下的trubo?C，初学者甚至不用装其它的编译器，就可以练习编程了,非常适合初学者。还有一个“C语言学习系统”软件，不过感觉只是一个题库系统，如果你觉得题做的不够，不妨也可以试试。

2:葵花宝典
学习计算机语言最好的方法是什么？答曰：读程序。
没错，读程序是学习C语言入门最快，也是最好的方法。如同我，现在学习新的J#,C#等其他语言，不再是抱着书本逐行啃，而是学习它们的例程。当然，对于没有学过任何计算机语言的初学者，最好还是先阅读教程，学习完每一章，都要认真体会这一章的所有概念，然后不放过这一章中提到的所有例程，然后仔细研读程序，直到每一行都理解了，然后找几个编程题目，最好是和例程类似的或一样的，自己试图写出这段已经读懂的程序，不要以为例程你已经读懂了，你就可以写出和它一样的程序，绝对不一定，不相信你就试一试吧，如果写不出来，也不要着急，回过头来再继续研究例程，想想自己为什么写不出来，然后再去写这段程序，反反复复，直到你手到擒来为止，祝贺你，你快入门了。

3：登峰造极
写程序的最高境界其实就是掌握各种解决问题的手段(数据结构)和解决问题的方法(算法)。?
是不是写出底层程序就是程序设计高手呢？非也，写底层程序，无非是掌握了硬件的结构，况且硬件和硬件还不一样，要给一个芯片写驱动程序，无非就是掌握这块芯片的各种寄存器及其组合，然后写值读值，仅此而已。这不过是熟悉一些io函数罢了。
那么怎样才算精通程序设计呢？怎样才能精通程序设计呢？举个例子：你面前有10个人，找出一个叫“张三”的人，你该怎么办？第一种方法：直接对这10个人问：“谁叫张三”。第2种方法：你挨个去问“你是不是张三？”，直到问到的这个人就是张三。第三种方法：你去挨个问一个人“你认不认识张三，指给我看”。不要小看这个问题，你说当然会选第一种方法，没错恭喜你答对了，因为这个方法最快，效率最高，但是在程序设计中找到解决问题的最优方法和你用的手段却是考验一个程序员程序设计水平的重要标志，而且是不容易达到的。刚才这个问题类似于数据结构和算法中的：Map数据结构，穷举查找和折半查找。所以掌握好数据结构和一些常用算法，是登峰造极的必然之路。

❺ 数据结构与算法分析 c语言秒速 csdn 好吗

Sub s()
On Error Resume Next
Dim pth$, fn$, wb As Workbook

❻ 什么是c语言局部程序块 csdn

局部程序块是指一对大括号({})之间的一段C语言程序。一个C函数包含一对大括号，这对大括号之间的所有内容都包含在一个局部程序块中。if语句和swich语句也可以包含一对大括号，每对大括号之间的代码也属于一个局部程序块。 此外，你完全可以创建你自己的局部程序块，而不使用C函数或基本的C语句。 你可以在局部程序块中说明一些变量，这种变量被称为局部变量，它们只能在局部程序块的开始部分说明，并且只在说明它的局部程序块中有效。如果局部变量与局部程序块以外的变量重名，则前者优先于后者。 下面是一个使用局部程序块的例子： #include <stdio.h> void main(void); void main(){/ * Begin local block for function main() * / int test_ var = 10; printf("Test variable before the if statement: %d\n", test_var); if (test_var>5){/ * Begin local block for "if" statement * / int test_ var = 5; printf("Test variable within the if statement: %d\n", test_var);{/ * Begin independent local block (not tied to any function or keyword) * / int test_var = 0;printf ("Test variable within the independent local block: %d\n", test_var)}/ * End independent local block * / printf ("Test variable after the if statement: %d\n", test_var);}/*End local block for function main () * / 上例产生如下输出结果： Test variable before the if statement: 10 Test variable within the if statement: 5 Test variable within the independent local block:0 注意：在这个例子中，每次test_var被定义时，它都要优先于前面所定义的test_var变量。

❼ 求c语言十进制数字转换为十六进制的算法

int num,i=0,a[10],r_gitil,j;
printf("请输入一个十进制整数:");
scanf("%d",&num);
while(num!=0)
{
i++;
r_gitil=num%16;
for(j=i-1;j<i;j++)
{
a[j]=r_gitil;
}
num=num/16;
}
printf("转为十六进制为:");
for(j=i-1;j>=0;j--)
{
switch(a[j])
{
case 10: a[j]='A';printf("%c",a[j]);break;
case 11: a[j]='B';printf("%c",a[j]);break;
case 12: a[j]='C';printf("%c",a[j]);break;
case 13: a[j]='D';printf("%c",a[j]);break;
case 14: a[j]='E';printf("%c",a[j]);break;
case 15: a[j]='F';printf("%c",a[j]);break;
default:
printf("%d",a[j]);
}
}
printf("\n\n");

❽ c语言方法怎么理解csdn

方法实际上就是成员函数，另外一个概念就是数据成员，也叫属性，成员函数一般都要操作数据成员

❾ 如何用c语言编写同步与互斥线程 csdn

pthread_create(pthread_t *thread, pthread_attr_t * attr, void *(*start_routine)(void *),void *arg);创建线程（默认为同步线程）
线程的互斥函数有：互斥函数的初始化pthread_mutex_init（），互斥函数的锁定函数pthread_mutex_lock（），互斥函数的预锁定函数pthread_mutex_trylock（），互斥函数的解锁函数pthread_mutex_unlock（），互斥函数的销毁函数pthread_mutex_destroy（）

❿ 时间片轮转算法和优先级调度算法 C语言模拟实现

一、目的和要求
进程调度是处理机管理的核心内容。本实验要求用高级语言编写模拟进程调度程序，以便加深理解有关进程控制快、进程队列等概念，并体会和了解优先数算法和时间片轮转算法的具体实施办法。
二、实验内容
1.设计进程控制块PCB的结构，通常应包括如下信息：
进程名、进程优先数（或轮转时间片数）、进程已占用的CPU时间、进程到完成还需要的时间、进程的状态、当前队列指针等。
2.编写两种调度算法程序：
优先数调度算法程序
循环轮转调度算法程序
3.按要求输出结果。
三、提示和说明
分别用两种调度算法对伍个进程进行调度。每个进程可有三种状态；执行状态（RUN）、就绪状态（READY,包括等待状态）和完成状态（FINISH），并假定初始状态为就绪状态。
（一）进程控制块结构如下：
NAME——进程标示符
PRIO/ROUND——进程优先数/进程每次轮转的时间片数（设为常数2）
CPUTIME——进程累计占用CPU的时间片数
NEEDTIME——进程到完成还需要的时间片数
STATE——进程状态
NEXT——链指针
注：
1.为了便于处理，程序中进程的的运行时间以时间片为单位进行计算；
2.各进程的优先数或轮转时间片数，以及进程运行时间片数的初值，均由用户在程序运行时给定。
（二）进程的就绪态和等待态均为链表结构，共有四个指针如下：
RUN——当前运行进程指针
READY——就需队列头指针
TAIL——就需队列尾指针
FINISH——完成队列头指针
（三）程序说明
1. 在优先数算法中，进程优先数的初值设为：
50-NEEDTIME
每执行一次，优先数减1，CPU时间片数加1，进程还需要的时间片数减1。
在轮转法中，采用固定时间片单位（两个时间片为一个单位），进程每轮转一次，CPU时间片数加2，进程还需要的时间片数减2，并退出CPU，排到就绪队列尾，等待下一次调度。
2. 程序的模块结构提示如下：
整个程序可由主程序和如下7个过程组成：
（1）INSERT1——在优先数算法中，将尚未完成的PCB按优先数顺序插入到就绪队列中；
（2）INSERT2——在轮转法中，将执行了一个时间片单位（为2），但尚未完成的进程的PCB，插到就绪队列的队尾；
（3）FIRSTIN——调度就绪队列的第一个进程投入运行；
（4）PRINT——显示每执行一次后所有进程的状态及有关信息。
（5）CREATE——创建新进程，并将它的PCB插入就绪队列；
（6）PRISCH——按优先数算法调度进程；
（7）ROUNDSCH——按时间片轮转法调度进程。
主程序定义PCB结构和其他有关变量。
（四）运行和显示
程序开始运行后，首先提示：请用户选择算法，输入进程名和相应的NEEDTIME值。
每次显示结果均为如下5个字段：
name cputime needtime priority state
注：
1．在state字段中，"R"代表执行态，"W"代表就绪（等待）态，"F"代表完成态。
2．应先显示"R"态的，再显示"W"态的，再显示"F"态的。
3．在"W"态中，以优先数高低或轮转顺序排队；在"F"态中，以完成先后顺序排队。

view plain to clipboardprint?
/*
操作系统实验之时间片轮转算法和优先级调度算法
By Visual C++ 6.0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
char name[20]; /*进程的名字*/
int prio; /*进程的优先级*/
int round; /*分配CPU的时间片*/
int cputime; /*CPU执行时间*/
int needtime; /*进程执行所需要的时间*/
char state; /*进程的状态，W——就绪态，R——执行态，F——完成态*/
int count; /*记录执行的次数*/
struct node *next; /*链表指针*/
}PCB;
PCB *ready=NULL,*run=NULL,*finish=NULL; /*定义三个队列，就绪队列，执行队列和完成队列*/
int num;
void GetFirst(); /*从就绪队列取得第一个节点*/
void Output(); /*输出队列信息*/
void InsertPrio(PCB *in); /*创建优先级队列，规定优先数越小，优先级越高*/
void InsertTime(PCB *in); /*时间片队列*/
void InsertFinish(PCB *in); /*时间片队列*/
void PrioCreate(); /*优先级输入函数*/
void TimeCreate(); /*时间片输入函数*/
void Priority(); /*按照优先级调度*/
void RoundRun(); /*时间片轮转调度*/
int main(void)
{
char chose;
printf("请输入要创建的进程数目:\n");
scanf("%d",&num);
getchar();
printf("输入进程的调度方法：(P/R)\n");
scanf("%c",&chose);
switch(chose)
{
case 'P':
case 'p':
PrioCreate();
Priority();
break;
case 'R':
case 'r':
TimeCreate();
RoundRun();
break;
default:break;
}
Output();
return 0;
}
void GetFirst() /*取得第一个就绪队列节点*/
{
run = ready;

if(ready!=NULL)
{
run ->state = 'R';
ready = ready ->next;
run ->next = NULL;
}
}
void Output() /*输出队列信息*/
{
PCB *p;
p = ready;
printf("进程名\t优先级\t轮数\tcpu时间\t需要时间\t进程状态\t计数器\n");
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = finish;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
p = run;
while(p!=NULL)
{
printf("%s\t%d\t%d\t%d\t%d\t\t%c\t\t%d\n",p->name,p->prio,p->round,p->cputime,p->needtime,p->state,p->count);
p = p->next;
}
}
void InsertPrio(PCB *in) /*创建优先级队列，规定优先数越小，优先级越低*/
{
PCB *fst,*nxt;
fst = nxt = ready;

if(ready == NULL) /*如果队列为空，则为第一个元素*/
{
in->next = ready;
ready = in;
}
else /*查到合适的位置进行插入*/
{
if(in ->prio >= fst ->prio) /*比第一个还要大，则插入到队头*/
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL) /*移动指针查找第一个别它小的元素的位置进行插入*/
{
nxt = fst;
fst = fst->next;
}

if(fst ->next == NULL) /*已经搜索到队尾，则其优先级数最小，将其插入到队尾即可*/
{
in ->next = fst ->next;
fst ->next = in;
}
else /*插入到队列中*/
{
nxt = in;
in ->next = fst;
}
}
}
}
void InsertTime(PCB *in) /*将进程插入到就绪队列尾部*/
{
PCB *fst;
fst = ready;

if(ready == NULL)
{
in->next = ready;
ready = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void InsertFinish(PCB *in) /*将进程插入到完成队列尾部*/
{
PCB *fst;
fst = finish;

if(finish == NULL)
{
in->next = finish;
finish = in;
}
else
{
while(fst->next != NULL)
{
fst = fst->next;
}
in ->next = fst ->next;
fst ->next = in;
}
}
void PrioCreate() /*优先级调度输入函数*/
{
PCB *tmp;
int i;

printf("输入进程名字和进程所需时间：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar(); /*吸收回车符号*/
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 50 - tmp->needtime; /*设置其优先级，需要的时间越多，优先级越低*/
tmp ->round = 0;
tmp ->count = 0;
InsertPrio(tmp); /*按照优先级从高到低，插入到就绪队列*/
}
}
void TimeCreate() /*时间片输入函数*/
{
PCB *tmp;
int i;

printf("输入进程名字和进程时间片所需时间：\n");
for(i = 0;i < num; i++)
{
if((tmp = (PCB *)malloc(sizeof(PCB)))==NULL)
{
perror("malloc");
exit(1);
}
scanf("%s",tmp->name);
getchar();
scanf("%d",&(tmp->needtime));
tmp ->cputime = 0;
tmp ->state ='W';
tmp ->prio = 0;
tmp ->round = 2; /*假设每个进程所分配的时间片是2*/
tmp ->count = 0;
InsertTime(tmp);
}
}
void Priority() /*按照优先级调度，每次执行一个时间片*/
{
int flag = 1;

GetFirst();
while(run != NULL) /*当就绪队列不为空时，则调度进程如执行队列执行*/
{
Output(); /*输出每次调度过程中各个节点的状态*/
while(flag)
{
run->prio -= 3; /*优先级减去三*/
run->cputime++; /*CPU时间片加一*/
run->needtime--;/*进程执行完成的剩余时间减一*/
if(run->needtime == 0)/*如果进程执行完毕，将进程状态置为F，将其插入到完成队列*/
{
run ->state = 'F';
run->count++; /*进程执行的次数加一*/
InsertFinish(run);
flag = 0;
}
else /*将进程状态置为W，入就绪队列*/
{
run->state = 'W';
run->count++; /*进程执行的次数加一*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst(); /*继续取就绪队列队头进程进入执行队列*/
}
}
void RoundRun() /*时间片轮转调度算法*/
{

int flag = 1;

GetFirst();
while(run != NULL)
{
Output();
while(flag)
{
run->count++;
run->cputime++;
run->needtime--;
if(run->needtime == 0) /*进程执行完毕*/
{
run ->state = 'F';
InsertFinish(run);
flag = 0;
}
else if(run->count == run->round)/*时间片用完*/
{
run->state = 'W';
run->count = 0; /*计数器清零，为下次做准备*/
InsertTime(run);
flag = 0;
}
}
flag = 1;
GetFirst();
}