编个算法

⑴ 如何写一个算法

算法是在有限步骤内求解某一问题所使用的一组定义明确的规则。通俗点说，就是计算机解题的过程。在这个过程中，无论是形成解题思路还是编写程序，都是在实施某种算法。前者是推理实现的算法，后者是操作实现的算法。 一个算法应该具有以下五个重要的特征： 1、有穷性： 一个算法必须保证执行有限步之后结束； 2、确切性： 算法的每一步骤必须有确切的定义； 3、输入：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定除了初始条件； 4、输出：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的； 5、可行性： 算法原则上能够精确地运行，而且人们用笔和纸做有限次运算后即可完成。 当遇到一个算法问题时,首先要知道自己以前有没有处理过这种问题.如果见过,那么你一般会顺利地做出来;如果没见过,那么考虑以下问题: 当遇到一个算法问题时,首先要知道自己以前有没有处理过这种问题.如果见过,那么你一般会顺利地做出来;如果没见过,那么考虑以下问题: 1. 问题是否是建立在某种已知的熟悉的数据结构(例如,二*树)上?如果不是,则要自己设计数据结构。 2. 问题所要求编写的算法属于以下哪种类型?(建立数据结构,修改数据结构,遍历,查找,排序...)3. 分析问题所要求编写的算法的数学性质.是否具备递归特征?(对于递归程序设计,只要设计出合理的参数表以及递归结束的条件,则基本上大功告成.)4. 继续分析问题的数学本质.根据你以前的编程经验,设想一种可能是可行的解决办法,并证明这种解决办法的正确性.如果题目对算法有时空方面的要求,证明你的设想满足其要求.一般的,时间效率和空间效率难以兼得.有时必须通过建立辅助存储的方法来节省时间.5. 通过一段时间的分析,你对解决这个问题已经有了自己的一些思路.或者说,你已经可以用自然语言把你的算法简单描述出来.继续验证其正确性,努力发现其中的错误并找出解决办法.在必要的时候(发现了无法解决的矛盾),推翻自己的思路,从头开始构思.6. 确认你的思路可行以后,开始编写程序.在编写代码的过程中,尽可能把各种问题考虑得详细,周密.程序应该具有良好的结构,并且在关键的地方配有注释.7. 举一个例子,然后在纸上用笔执行你的程序,进一步验证其正确性.当遇到与你的设想不符的情况时,分析问题产生的原因是编程方面的问题还是算法思想本身有问题. 8. 如果程序通过了上述正确性验证,那么在将其进一步优化或简化。 9. 撰写思路分析,注释. ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------看不懂，还是不明白，有谁清楚告诉我啊，

⑵ 帮忙编写一个算法

#include<iostream>
#include<string>
#include<stack>
using namespace std;
int main()
{
char a[100];
int i,j;
stack<char>aa;
scanf("%s",a);
getchar();
i=strlen(a)/2;
for(j=1;j<=i;j++)
aa.push(a[j-1]);
if(strlen(a)%2==0)
for(j=i+1;j<=strlen(a);j++)
{
if(aa.top()==a[j-1])
aa.pop();
else
break;
}
if(aa.size()==0)
printf("是回文数");
else
printf("不是会文数");
getchar();
return 0;
}

这是C语言写的，就是头文件用的是C++的，因为在C语言里面不能直接用栈，建议你学习一下C++的输入输出函数，以及用的头文件，很简单，大约五分钟就可以学会了！希望对你有帮助！呵呵

⑶ 编程算法有哪些

具体算法如下：

1、快速排序算法快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο（nlogn)次比较。在最坏状况下则需要Ο（n2)次比较，但这种状况并不常见。

2、堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

3、归并排序（Mergesort，台湾译作：合并排序）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（DivideandConquer）的一个非常典型的应用。

4、二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束。

5、BFPRT算法解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分析，BFPRT可以保证在最坏情况下仍为线性时间复杂度。

6、深度优先搜索算法，是搜索算法的一种。它沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。

⑷ 编写一个算法，用单链表表示的待排序关键码序列上实现简单选择排序。（用c写）

#include"stdio.h"
#include<malloc.h>

typedef char ElemType;

typedef struct LNode
{ElemType data;
struct LNode *next;
}LinkList;

void CreateListR(LinkList *&L,ElemType a[],int n) //尾插法建表
{
LinkList *s,*r;int i;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}

void InitList(LinkList *&L) //初始化线性表
{
L=(LinkList *)malloc(sizeof(LinkList));
L->next=NULL;
}

void DispList(LinkList *L) //输出线性表
{
LinkList *p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
}

void CombList(LinkList *L1,LinkList *L2,LinkList *&k) //两个集合的交
{
LinkList *p=L1->next ,*q=L2->next ,*b,*a,*c;

k=(LinkList *)malloc(sizeof(LinkList));
b=k;a=p;
while(q!=NULL)
{
while(a!=NULL)
{
if(a->data==q->data)
{
c=(LinkList *)malloc(sizeof(LinkList));
c->data=a->data;b->next=c;b=b->next;
}
a=a->next;
}
q=q->next;
a=p;
}
b->next=NULL;
}

void AddList(LinkList *L1,LinkList *L2,LinkList *&k) //两个集合的并
{
LinkList *p=L1->next ,*q=L2->next ,*b,*a,*c;

k=(LinkList *)malloc(sizeof(LinkList));
b=k;a=p;

while(q!=NULL)
{
int x=0;
while(p!=NULL)
{
if(p->data==q->data)x++;
p=p->next;
}
if(!x)
{
c=(LinkList *)malloc(sizeof(LinkList));
c->data=q->data;b->next=c;b=b->next;
}
q=q->next;
p=a;
}
b->next=a;
}

void RankList(LinkList *&L) //按从小到大排列
{
LinkList *p=L->next,*q,*r;
if (p!=NULL)
{ r=p->next;
p->next=NULL;
p=r;
while (p!=NULL)
{ r=p->next;
q=L;
while (q->next!=NULL && q->next->data<p->data)
q=q->next;
p->next=q->next;
q->next=p;
p=r;
}
}
}
int main()
{
ElemType a[5]={'a','b','c','d','e'},b[4]={'e','f','g','h'};
LinkList *h1,*h2,*p1,*p2;

InitList(h1); //初始化顺序表h
InitList(h2);
CreateListR(h1,&a[0],5); //依次采用尾插入法插入a，b，c，d，e元素
CreateListR(h2,&b[0],4);
printf("单链表1为：");
DispList(h1); printf("\n"); //输出顺序表h
printf("单链表2为：");
DispList(h2); printf("\n");

CombList(h1,h2,p1); //求两个单链表的交
printf("这两个单链表的交为：");
DispList(p1); printf("\n");

AddList(h1,h2,p2); //求两个单链表的并
printf("这两个单链表的并为：");
DispList(p2); printf("\n");

RankList(p2); //对单链表按从小到大排列
printf("这个单链表排列后为：");
DispList(p2); printf("\n");

return 0;
}

这个是我以前做的作业，你可拿去借鉴一下，其实程序这东西还是要自己多看多写，自然就会不断进步，如果只是拿别人的而不自己去思考很难有进步哦。
祝你能学习进步。

⑸ 编写一个递归算法，求长度为n的一维数组中的最大元素。

楼上的代码写得有点繁琐，其实一个简单的if结构就可以实现这个递归。
#include
<iostream>
using
namespace
std;
int
max(int
[],int);
//
max函数原型
int
main()
{
int
a[10]={1,3,8,2,4,9,5,7,6,0};
cout
<<
"a数组最大元素为："
<<
max(a,10)
<<
endl;
return
0;
}
int
max(int
arr[],
int
size)
//
max函数定义
{
if
(size
==
2)
return
arr[0]
>
arr[1]
?
arr[0]
:
arr[1];
else
return
max(arr,size
-
1)
>
arr[size
-
1]
?
max(arr,size
-
1)
:
arr[size
-
1];
}

⑹ 试编写一个算法，把单链表改变成循环链表

将单链表改成循环链表只需将单链表最后一个结点的指针指向头结点，即p->next = head。
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。其数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
循环链表也是一种链式存贮结构。和单链表相比，循环链表中最后一个结点的指针域指向头结点，整个链表形成一个环。

⑺ 编写一个算法，逐个输出顺序表中所有数据元素。设数据元素的类型为int型

编写的程序是：

#include <stdio.h>

#define maxsize 20

typedef int datatype;

typedef struct{datatype data[maxsize];int last;}sequenlist;

void CreateList(sequenlist *L,int n)

{int i;printf("please input n numbers ");for(i=0;i<n;i++)

{scanf("%d",&L->data[i]);(*L).last=n;}

}void PrintList(sequenlist *L,int n){int i;

printf("the sequenlist is ");for(i=0;i<n;i++ printf("%d ",L->data[i]);

}main(){

int i,x;

int n=10;

sequenlist L;

CreateList(&L,n);

PrintList(&L,n);

getchar();

getchar(); }

⑻ 如何编写一个算法

实现逆转的函数为void ReverseQueue()，其他的都是辅助测试所用。

#include "stdio.h"
#include "stdlib.h"
#include "time.h"
#include "math.h"

#define MAX 10

struct Queue
{
int front;
int rear;
int a[MAX];
}Que;

void Initial();
int InsertQueue(int n);
int DeleQueue();
void ReverseQueue();
void PrintQ();
//该函数是为了测试逆转函数的正确性
void TestFun();

int main()
{

Initial();
TestFun();
return 0;
}

void Initial()
{
Que.front=0;
Que.rear=0;
for (int i=0; i<MAX; i++)
{
Que.a[i] = 0;
}
}
int InsertQueue(int n)
{
if ( (Que.rear+1)%MAX == Que.front )
{
return 0;
}
Que.a[Que.rear] = n;
Que.rear = (Que.rear+1)%MAX;
return 1;
}

int DeleQueue()
{
if (Que.rear == Que.front)
{
return 0;
}
int temp;
temp = Que.a[Que.front];
Que.front++;
return temp;
}

void ReverseQueue()
{
int len;
len = (Que.rear-Que.front+MAX)%MAX;//total number in the queue
int start,end;
start = Que.front;
end = (Que.front+(len-1))%MAX;//the last number's index
int temp=0;
for (int i=0; i<len/2; i++)
{
temp = Que.a[end];
Que.a[end] = Que.a[start];
Que.a[start] = temp;
start = (start+1)%MAX;
end = (end-1+MAX)%MAX;
}
}

void PrintQ()
{
printf("\n");
int len = (Que.rear-Que.front+MAX)%MAX;
int k=Que.front;
for (int i=Que.front; i<Que.front+len; i++)
{
printf("%d ",Que.a[k]);
k = (k+1)%MAX;
}
}
//该函数是为了测试逆转函数的正确性
void TestFun()
{
int i=0;
for (i=0; i<MAX; i++)
{
if (InsertQueue(i) == 0)
{
printf("\nQueue is full!");
break;
}
}
PrintQ();
for (i=0; i<MAX/2; i++)
{
DeleQueue();
}
printf("\nAfeter delete %d number in the queue",MAX/2);
PrintQ();
ReverseQueue();
printf("\nReverse ==>");
PrintQ();
for (i=0; i<MAX/2; i++)
{
InsertQueue(i*8);
}
printf("\nAfter insert %d number in the queue",MAX/2);
PrintQ();
ReverseQueue();
printf("\nReverse ==>");
PrintQ();
printf("\n");
}

⑼ 编写一个算法，在顺序表中统计值为x的数据元素的个数

intcount(intx,int*a,intn)
{
inti,num=0;
for(i=0;i<n;i++)
if(a[i]==x)num++;
returnnum;
}

⑽ 用C语言编写一个快速排序算法 输入10个数

代码如下：
#include <stdio.h>
#define N 10
void quickSort(int *arr,int l,int r)
{//此处编写代码实现快速排序
int i,j,x,temp;
if(l<r)
{
i=l;
j=r;
x=arr[(l+r)/2]; //以中间元素为轴
while(1)
{
while(i<=r&&arr[i]<x)i++;
while(j>=0&&arr[j]>x)j--;

if(i>=j) //相遇则跳出
break;
else
{
temp=arr[i];arr[i]=arr[j];arr[j]=temp; //交换
}
}
qsort(arr,l,i-1); //对左半部分进行快排
qsort(arr,j+1,r); //对右半部分进行快排
}
}
void printArray(int *a)
{//此处编写代码打印数组
int i=0;
for(;i<N;i++)
printf("%d\t",a[i]);
printf("\n");
}

int main()
{
int a[N];
int i;
for(i=0;i<N;i++)
scanf("%d",a+i);
printf("排序前的数据为:\n");
printArray(a);
//调用快速排序函数，对数组中从0到N的元素进行快速排序
quickSort(a,0,N-1);

printf("从小到大排序后的序列为:\n");
printArray(a);
return 0;
}