编写一个算法程序实现在一个顺序栈中把一个字符串逆置的运算，要求使用入栈和出栈运算来完成。

void ReverseString(char a,int lenth) //逆转函数

{

int i;

char c;

initstack(&s);

for(i=0;i<lenth;i++) Push(&s,a[i]);

for(i=0;i<lenth;i++) {Pop(&s,&c);a[i]=c;}

}

---------------------------------------------------------------------

typedef struct //循环队列定义

{

int data[4];

int front;

int rear;

}SeqQueue;

void InitQueue(SeqQueue Q) //初始化函数

{

Q->front=Q->rear=0;

}

int EnterQueue(SeqQueue Q,int x) //入队函数

{

if((Q->rear+1)%4==Q->front) return 0;

Q->data[Q->rear]=x;

Q->rear=(Q->rear+1)%4

return 1;

}

写个main函数调用两次入队即可！

程序算法是对特定问题求解过程的描述，是指令的有限序列，每条指令完成一个或多个 *** 作。通俗地讲，就是为解决某一特定问题而采取的具体有限的 *** 作步骤。

在有限的 *** 作步骤内完成。有穷性是算法的重要特性，任何一个问题的解决不论其采取什么样的算法，其终归是要把问题解决好。如果一种算法的执行时间是无限的，或在期望的时间内没有完成，那么这种算法就是无用和徒劳的，我们不能称其为算法。

相关信息：

算法的时间复杂度是指算法需要消耗的时间资源。一般来说，计算机算法是问题规模n 的函数f(n)，算法的时间复杂度也因此记做T(n)=Ο(f(n))；因此，问题的规模n 越大，算法执行的时间的增长率与f(n) 的增长率正相关，称作渐进时间复杂度（Asymptotic Time Complexity）。

算法的空间复杂度是指算法需要消耗的空间资源。其计算和表示方法与时间复杂度类似，一般都用复杂度的渐近性来表示。同时间复杂度相比，空间复杂度的分析要简单得多。

选择排序如下：

#include <stdioh>

#include <stdlibh>

void choose_sort( int array[], int s, int e );

int main( void )

{

int array[100];

int num;

int i;

int j;

int k;

printf( "input the amout(<100) of the array:" );

scanf( "%d", &num );

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

{

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

}

choose_sort( array, 0, num - 1 );

/

for( i = 0; i < num - 1; i++ )

{

k = i;

for( j = i + 1; j < num; j++ )

{

k = array[j] < array[k] j : k;

}

if( i != k )

{

array[i] ^= array[k];

array[k] ^= array[i];

array[i] ^= array[k];

}

}

/

printf( "the result of choose sort:\n" );

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

{

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

}

printf( "\n" );

system( "pause" );

return 0;

}

void choose_sort( int array[], int s, int e )

{

int i;

int j;

int k;

for( i = s; i < e; i++ )

{

k = i;

for( j = i + 1; j <= e; j++ )

{

k = array[k] > array[j] j : k;

}

if( k != i )

{

array[i] ^= array[k];

array[k] ^= array[i];

array[i] ^= array[k];

}

}

}

插入排序如下：

#include <stdioh>

#include <stdlibh>

//already check /

void insert_sort( int array[], int s, int e );

int main( void )

{

int array[100];

int num;

int i;

int key;

int j;

printf( "input the amount(<100) of array: " );

scanf( "%d", &num );

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

{

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

}

insert_sort( array, 0, num - 1 );

/

for( i = 1; i < num; i++ )

{

key = array[i];

j = i - 1;

while( j >= 0 && array[j] > key )

{

array[j + 1] = array[j];

j--;

}

array[j + 1] = key;

}

/

printf( "insert sort result:\n" );

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

{

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

}

printf( "\n" );

system( "pause" );

return 0;

}

void insert_sort( int array[], int s, int e )

{

int i;

int j;

int key;

for( i = s + 1; i <= e; i++)

{

key = array[i];

for( j = i - 1; j >= s && array[j] > key; j-- )

{

array[j + 1] = array[j];

}

array[j + 1] = key;

}

}

冒泡排序如下：

#include <stdioh>

#include <stdlibh>

void bubble_sort( int array[], int s, int e );

int main( void )

{

int i;

int num;

int array[100];

printf( "input amount(<100) of number: " );

scanf( "%d", &num );

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

{

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

}

bubble_sort( array, 0, num - 1 );

printf( "result of bubble sort:\n" );

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

{

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

}

printf( "\n" );

system( "pause" );

return 0;

}

/

void bubble_sort( int array[], int s, int e )

{

int i;

int j;

for( i = e; i > s; i-- )

{

for( j = s + 1; j <= i; j++ )

{

if( array[j - 1] > array[j] )

{

array[j] ^= array[j - 1];

array[j - 1]^= array[j];

array[j] ^= array[j - 1];

}

}

}

}

/

注意：以上三个算法的main函数部分是为了让你输入一些数来测试排序算法而写的，排序的具体实现另写成一个函数。

补充题：

#include <stdioh>

#include <stdlibh>

#include <stringh>

int search(char str1, char str2);

main()

{

char str1[100];

char str2[100];

int result;

printf("input first string: ");

scanf("%s", str1);

printf("input first string: ");

scanf("%s", str2);

result = search(str1, str2);

if(result < 0){

printf("str2 is not in str1\n");

}

else{

printf("str2 is in str1, and begins at %d\n", result);

}

system("pause");

}

int search(char str1, char str2){

int len1 = strlen(str1);

int len2 = strlen(str2);

int i;

int j;

int k;

i = 0;

while(i <= len1 - len2){

j = 0;

k = i;

while(j < len2 && str1[k] == str2[j]){

j++;

k++;

}

if(j == len2){

return i;

}

i++;

}

return -1;

}

注意：main也是测试用的，具体实现写成一个函数

要余数的话，大多数语言应该都有取余运算：%，

a%b表示取a/b的余数，余数为0则表示整。例如：5%2=1。

如果实在没有，也可以考虑利用计算机计算整型变量除法时候的舍弃位数实现：

a-a/bb，可以得到余数。例如：

5-5/22

=5-22

=5-4

=1

计算机计算不会去约分的，同级自左至右依次运算

真不容易啊，怕是没人弄了!

优先级调度算法程序:

#include "stdioh"

#include "stdlibh"

#include "stringh"

typedef struct node

{

char name[10]; /进程标识符/

int prio; /进程优先数/

int round; /进程时间轮转时间片/

int cputime; /进程占用CPU时间/

int needtime; /进程到完成还要的时间/

int count; /计数器/

char state; /进程的状态/

struct node next; /链指针/

}PCB;

PCB finish,ready,tail,run; /队列指针/

int N; /进程数/

/将就绪队列中的第一个进程投入运行/

firstin()

{

run=ready; /就绪队列头指针赋值给运行头指针/

run->state='R'; /进程状态变为运行态/

ready=ready->next; /就绪对列头指针后移到下一进程/

}

/标题输出函数/

void prt1(char a)

{

if(toupper(a)=='P') /优先数法/

printf(" name cputime needtime priority state\n");

else

printf(" name cputime needtime count round state\n");

}

/进程PCB输出/

void prt2(char a,PCB q)

{

if(toupper(a)=='P') /优先数法的输出/

printf(" %-10s%-10d%-10d%-10d %c\n",q->name,

q->cputime,q->needtime,q->prio,q->state);

else/轮转法的输出/

printf(" %-10s%-10d%-10d%-10d%-10d %-c\n",q->name,

q->cputime,q->needtime,q->count,q->round,q->state);

}

/输出函数/

void prt(char algo)

{

PCB p;

prt1(algo); /输出标题/

if(run!=NULL) /如果运行指针不空/

prt2(algo,run); /输出当前正在运行的PCB/

p=ready; /输出就绪队列PCB/

while(p!=NULL)

{

prt2(algo,p);

p=p->next;

}

p=finish; /输出完成队列的PCB/

while(p!=NULL)

{

prt2(algo,p);

p=p->next;

}

getch(); /压任意键继续/

}

/优先数的插入算法/

insert1(PCB q)

{

PCB p1,s,r;

int b;

s=q; /待插入的PCB指针/

p1=ready; /就绪队列头指针/

r=p1; /r做p1的前驱指针/

b=1;

while((p1!=NULL)&&b) /根据优先数确定插入位置/

if(p1->prio>=s->prio)

{

r=p1;

p1=p1->next;

}

else

b=0;

if(r!=p1) /如果条件成立说明插入在r与p1之间/

{

r->next=s;

s->next=p1;

}

else

{

s->next=p1; /否则插入在就绪队列的头/

ready=s;

}

}

/轮转法插入函数/

insert2(PCB p2)

{

tail->next=p2; /将新的PCB插入在当前就绪队列的尾/

tail=p2;

p2->next=NULL;

}

/优先数创建初始PCB信息/

void create1(char alg)

{

PCB p;

int i,time;

char na[10];

ready=NULL; /就绪队列头指针/

finish=NULL; /完成队列头指针/

run=NULL; /运行队列指针/

printf("Enter name and time of process\n"); /输入进程标识和所需时间创建PCB/

for(i=1;i<=N;i++)

{

p=malloc(sizeof(PCB));

scanf("%s",na);

scanf("%d",&time);

strcpy(p->name,na);

p->cputime=0;

p->needtime=time;

p->state='w';

p->prio=50-time;

if(ready!=NULL) /就绪队列不空调用插入函数插入/

insert1(p);

else

{

p->next=ready; /创建就绪队列的第一个PCB/

ready=p;

}

}

clrscr();

printf(" output of priority:\n");

printf("\n");

prt(alg); /输出进程PCB信息/

run=ready; /将就绪队列的第一个进程投入运行/

ready=ready->next;

run->state='R';

}

/轮转法创建进程PCB/

void create2(char alg)

{

PCB p;

int i,time;

char na[10];

ready=NULL;

finish=NULL;

run=NULL;

printf("Enter name and time of round process\n");

for(i=1;i<=N;i++)

{

p=malloc(sizeof(PCB));

scanf("%s",na);

scanf("%d",&time);

strcpy(p->name,na);

p->cputime=0;

p->needtime=time;

p->count=0; /计数器/

p->state='w';

p->round=2; /时间片/

if(ready!=NULL)

insert2(p);

else

{

p->next=ready;

ready=p;

tail=p;

}

}

clrscr();

printf(" output of round\n");

printf("\n");

prt(alg); /输出进程PCB信息/

run=ready; /将就绪队列的第一个进程投入运行/

ready=ready->next;

run->state='R';

}

/优先数调度算法/

priority(char alg)

{

while(run!=NULL) /当运行队列不空时，有进程正在运行/

{

run->cputime=run->cputime+1;

run->needtime=run->needtime-1;

run->prio=run->prio-3; /每运行一次优先数降低3个单位/

if(run->needtime==0) /如所需时间为0将其插入完成队列/

{

run->next=finish;

finish=run;

run->state='F'; /置状态为完成态/

run=NULL; /运行队列头指针为空/

if(ready!=NULL) /如就绪队列不空/

firstin(); /将就绪对列的第一个进程投入运行/

}

else /没有运行完同时优先数不是最大，则将其变为就绪态插入到就绪队列/

if((ready!=NULL)&&(run->prio<ready->prio))

{

run->state='W';

insert1(run);

firstin(); /将就绪队列的第一个进程投入运行/

}

prt(alg); /输出进程PCB信息/

}

}

/时间片轮转法/

roundrun(char alg)

{

while(run!=NULL)

{

run->cputime=run->cputime+1;

run->needtime=run->needtime-1;

run->count=run->count+1;

if(run->needtime==0)/运行完将其变为完成态，插入完成队列/

{

run->next=finish;

finish=run;

run->state='F';

run=NULL;

if(ready!=NULL)

firstin(); /就绪对列不空，将第一个进程投入运行/

}

else

if(run->count==run->round) /如果时间片到/

{

run->count=0; /计数器置0/

if(ready!=NULL) /如就绪队列不空/

{

run->state='W'; /将进程插入到就绪队列中等待轮转/

insert2(run);

firstin(); /将就绪对列的第一个进程投入运行/

}

}

prt(alg); /输出进程信息/

}

}

/主函数/

main()

{

char algo; /算法标记/

clrscr();

printf("type the algorithm:P/R(priority/roundrobin)\n");

scanf("%c",&algo); /输入字符确定算法/

printf("Enter process number\n");

scanf("%d",&N); /输入进程数/

if(algo=='P'||algo=='p')

{

create1(algo); /优先数法/

priority(algo);

}

else

if(algo=='R'||algo=='r')

{

create2(algo); /轮转法/

roundrun(algo);

}

}

以上就是关于编写一个算法程序实现在一个顺序栈中把一个字符串逆置的运算，要求使用入栈和出栈运算来完成。全部的内容，包括:编写一个算法程序实现在一个顺序栈中把一个字符串逆置的运算，要求使用入栈和出栈运算来完成。、编程算法是什么、编写程序，实现三种排序算法（选择、插入、冒泡）等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！