写个算法
#include <stdio.h>
#include<stdlib.h>
#include<time.h>
int InArray(int a[],int N,int data)/*判断data是否在数组a[N]中.是则返回1，否则返回0*/
{
int i;
for(i=0;i<N;i++)
if(data==a[i])
return 1;
return 0;
}
int main(void)
{
int i,j=1,temp,a[8]={0};
srand( (unsigned)time( NULL ) ); /*保证每次生成的随机数不相同*/
a[0]=rand()%8+1; /*数组第一项*/
for(i=1;i<8;i++)
{
temp=rand()%8+1;
if(InArray(a,8,temp))//当产生的随机数已存在
{i--;continue;}
else
a[j++]=temp;
}
for(i=0;i<8;i++)
printf("%d ",a[i]);
printf("\n");
return 0;
}
2. 写个算法（c语言）
/* 单链表就地逆置算法 */
void converse(NODEPTR L)
{
NODEPTR p,q;
p=L->next; q=p->next;
L->next=NULL;
while(p) /* 对于当前结点p，用头插法将结点p插入到头结点之后 */
{
p->next=L->next;
L->next=p;
p=q;
q=q->next;
}
}
买一送一吧：
-------------------------------
-------------------------------
/* 单链表就地逆置的C语言程序 */
#define NULL 0
/*定义单链表的数据类型 */
typedef struct node{
int data;
struct node * next;
}NODE,*NODEPTR;
/*创建单链表 */
NODEPTR createlink()
{
NODEPTR L,p,q;
int i,n,e;
L=(NODEPTR)malloc(sizeof(NODE));
L->next=NULL;
q=L;
printf("please input the length of the link list\n");
scanf("%d",&n);
for(i=1;i<=n;i++)
{
p=(NODEPTR)malloc(sizeof(NODE));
printf("please enter the value of the list element\n");
scanf("%d",&e);
p->data=e;
q->next=p;
q=p;
}
q->next=NULL;
return L;
}
/* 逐个输出单链表数据元素的值 */
void travlist(NODEPTR L)
{ NODEPTR p;
p=L->next;
printf("the value of the linklist:\n");
while(p)
{
printf("%d%s",p->data,"-->");
p=p->next;
}
printf("\n");
}
/* 单链表就地逆置 */
void converse(NODEPTR L)
{
NODEPTR p,q;
p=L->next; q=p->next;
L->next=NULL;
while(p) /* 对于当前结点p，用头插法将结点p插入到头结点之后 */
{
p->next=L->next;
L->next=p;
p=q;
q=q->next;
}
}
main()
{
NODEPTR L;
L=createlink();
travlist(L);
converse(L);
travlist(L);
}
3. 谁能帮我写一个算法
这个题目很明显的是用堆栈嘛。
先是手动输入的数据依次进栈，后面的工作就是依次出栈，每出一个数据就乘以一个10。
假设(没写参数)：InitStack();//初始化一个栈
Push();//进栈
Popsh();//出栈
EmptyStack();//判断一个栈是否为空，空返回1，否则为0
算法简略如下：
int temp,result;
InitStack(s);
scanf("%d",&count); //输入数据的个数
for(int i=0;i<count;i++)
{
scanf("%d",&data);
Push(s,data);
}
Pop(s,temp);
result=temp;
while(!stackempty(s))
{
Pop(s,temp);
result=10*result+temp;
}
4. 写一个算法,将一个顺序栈中的元素依次取出,并打印元素
对，后进先出。打印的顺序与原来输入的相反。
算法：
#define Stack_Size 20
typedef struct
{
int elem [Stack_Size];
int top ;/*存放栈顶元素的下标*/
} SeqStack;
void Pop (SeqStack *S,int x)
{
if(S->top==-1） /*栈为空*/
exit(0);
else
{
*x=S->elem[S->top];
printf("%d ",x); /*打印*/
S->top--; /*修改栈顶指针*/
}
}
5. 用c语言写算法
直接手写
size_t lenT, lenP, lenS;
char *e;
if ( !T || !P || !S ) return;
e = strstr( T, P );
if ( !e ) return;
lenT = strlen( T );
lenP = strlen( P );
lenS = strlen( S );
memmove( e+lenS, e+lenP, lenT+1-(e-T)-lenP );
memcpy( e, s, lenS );
假定三个长度 t、p、s 。
strstr: O(t*p)
strlen*3: O(t+p+s)
memmove: O(t-p)
memcpy:O(s)
最终复杂度 O(t*p+2(t+s)) -> O(n^2)。
可以看出热点在 strstr 函数。
如果将其通过 kmp 或类似的匹配算法优化成 O(n) 的，那么复杂度可以直接降为 O(n) 。
6. 写一个递归算法（数据结构）
简单，实现用结构数组，三个成员域， 变量名，表达式， 默认值，当然这个检索比较麻烦，我不能用变量名"A"直接找到，对应的其他值(必须要循环数组)，用C#的的字典对象就好办了<index,value>,这个不是关键
下面 写个函数 叫 defaulvalue cal( 变量名) {
if 变量名.默认值<> null 则 cal (计算公式); -- 递归开始,计算公式要进行解析,按单独变量来,还要解析运算符(有点复杂,如果涉及到运算符的优先判断,这里的都是平级的,还有进行运算符优先判断)
else reture 默认值 --递归终结
}
基本就这样,有点简单,还要仔细斟酌下
7. 写一个有效的算法来测试一个给定的数组A[1...n]是否是一个堆，该算法的时间复杂性是多少
时间复杂度是O(n)，可以从n到1，也可以从1到n，从n开始就看(k/2)下取整下标的元素（也就是堆中的双亲）是否满足大根或者小根的条件，从1开始就看2k和2k+1下标的元素（就是堆中的左右孩子）是否满足堆的条件
8. 写一个算法，求单链表中的最大值
可以参考下面的代码：
public static int FindMax(Node head)
{
if (head == null)
return 0;
int Max = head.value;
while(head.next != null)
{
if (head.next.value > Max)
Max = head.next.value;
head = head.next;
}
return Max;
(8)写个算法扩展阅读：
单链表的具体存储：
1、用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）
2、链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）
链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。