編個演算法

⑴ 如何寫一個演算法

演算法是在有限步驟內求解某一問題所使用的一組定義明確的規則。通俗點說，就是計算機解題的過程。在這個過程中，無論是形成解題思路還是編寫程序，都是在實施某種演算法。前者是推理實現的演算法，後者是操作實現的演算法。 一個演算法應該具有以下五個重要的特徵： 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;
}