驰骋草原的代码

nodetype *invert(nodetype *head){ nodetype *p=head,*q,*s; if(p!=NULL) {  q=p->next;  head->next=head->left;/////逆置头结点  head->left=p->next;  while(q!=head)  {   s=q->next;   q->le

采用顺序存储方式存储串，编写一个指环函数，将串s1中的第i个字符开始的以第J个字符结束的字符构成的子川用s2进行替换，函数名为replace(s1,i,j,s2).例如replace("abcd",1,3,"xyz")返回"xyzd"strtype *replace(strtype *s1,int i,int j,strtype *s2){ if(ilen(s1)) {  co

编写一个函数，计算子串s2在主串s1中出现的次数  int search(strtype *s1,strtype *s2,int i,int y){ if(i>=len(s1))  return y; else {  int k=i,j=0;  while(s1->ch[k]==s2->ch[j] && j  {   k++;   j++;

利用串的基本运算，编写一个算法删除串s1中所有的s2子串 void index(strtype *s1,strtype *s2);void search(strtype *s1,strtype *s2,int i){ if(i>=len(s1))  return ; else {  int k=i,j=0;  int m=k;  while(s1->ch

设数组R【】中的n个元素中有多个0元素，设计一个算法，将R中所有的非0元素一次移动到R数组的前端 void move(int R[],int n){ int i=0,j=n-1; while(i {  if(R[i]>0)   i++;  else if(R[i]==0)  {   int t=R[i];   R[i]=R[j];   R[j--

#include#include#include#define MaxLen 20typedef struct{ char ch[MaxLen]; int len;}strtype;void create(strtype *s,char str[]){ strcpy(s->ch,str); s->len=strlen(str);}in

编写一个双向冒泡排序算法，即在排序过程中以交替的正，反两个方向进行遍历，若第一趟吧关键字最大的记录放到最末尾，则在第二趟吧关键字最小的记录放到最前面。如此反复进行。 void dbubble(int a[],int i,int j,int flag){ int y,temp; if(i==j)  return; if(flag==1) {  for(y=i;y

一下是一个5*5阶的螺旋方阵，设计一个算法，输出该形式的n*n阶方阵12345161718196152425207142322218131211109void show(int R[][5],int n){ int k=1;

对两个给定的有序表（均从小到大），设计一个算法将他们归并为一个有序表 void merge(int a[],int n,int b[],int m){ int i,t=0,l,k; for(i=0;i {  int j=t;  while(j  {   if(a[j]    j++;   else    break;  }  if(j==

要求设计一个算法，设置m*n（m=3,n=3）的矩阵元素后，统计这个矩阵中具有以下特征的元素的个数，并输出他们的坐标及数值：他们既是所在行中的最小值又是所在列中的最小值，或者，他们既是所在行中的最大值，又是所在列中的最大值。 int findmax(int a[][3],int m,int i){ int max=a[i][0],maxj=0; for(int j=0;j

利用以为数组a可以对n个整数进行排序。其中一种排序的算法的处理思想是：n个整数非别作为数组A的N个元素的值，每次（即第i次）从元素a【i】-A[N]中挑出最小的一个元素元素a[k],然后将a[k]和a[i]进行交换。这样反复n次完成排序。编写如上算法的函数。 void sort(int a[],int n){ int min,minj,i,j; for(i=0;i {

对给定关键字的序号j，要求在无序记录a[0.....n-1]中找按关键字从小到大排在第j位上的记录，利用快速排序的划分思想设计上述算法  int split(int a[],int low,int high,int &i,int k){ int j,temp,t; i=low; j=high; t=a[i]; while(i {  while(i

split(int a[],int low,int high,int &i){ int j,temp,t; i=low; j=high; t=a[i]; while(i {  while(i   i++;  if(i  {  temp=a[i];  a[i]=a[j];  a[j]=temp;  j--;  }  while(i=

有一种简单的排序算法，叫做计数排序。这种排序算法岁一个待排序的表进行排序，并将排序结果存放在另一个新的表中。必须注意的是，表中所有待排序的关键字互不相同。计数排序算法针对表中的每一个记录，遍历待排序的表一遍，统计表中有多少个记录的关键字比该记录的关键字小。假如针对某一个记录，统计出计数值为c，那么，这个记录在新的有序表中合适的存放位置即为c。void sort(int a[],int b[],

#include#define MaxSize 30using namespace std;typedef char elemtype;typedef struct node{ elemtype data; struct node *left,*right;}BTree;BTree *create(char *str){ BTree *b,*stac

采用顺序结构存储串，编写函数，用于判定s2是否是s1的子串int search(strtype *s1,strtype *s2,int i){ if(i>=len(s1))  return 0; else {  int k=i,j=0;  while(s1->ch[k]==s2->ch[j] && j  {   k++;   j++;  }  i

某机车轮渡口，过江渡船每次只能载10辆车过江。过江车辆分为客车类和货车类，上船有如下规定：同类车先到先上船，客车先于货车上船。且每上4条客车，才允许上一辆货车；若等待的客车不足4辆，则以货车代替，若没有货车等待则允许客车都上船。设计一个算法模拟渡口管理。  squeue *f(squeue *sq,char s[]){ squeue *p=(squeue *)malloc(10

一个双向队列是限定在两端end1,end2都可以进行插入删除操作的线性表。对空调间是end1=end2.若用顺序方式来组织双端队列，试根据下列要求，定义双端队列的结构，并给出指定端（i=1,2）进行插入和删除操作 #include#include#define MaxLen 6typedef char elemtype;typedef struct node{ el

#include#include#define MaxLen 20/*typedef char elemtype;typedef struct stack{ elemtype data[MaxLen]; int top;}stack; stack *init(){ stack *p; p=(stack *)malloc(sizeof(stac

typedef char elemtype;typedef struct stack{ elemtype data[MaxLen]; int top;}stack; stack *init(){ stack *p; p=(stack *)malloc(sizeof(stack)); p->top=0; return p;}int push

nodetype* connect(nodetype* h1,nodetype* h2){ nodetype *h3,*h4,*head; if(h1==NULL)  return h2; if(h2==NULL)  return h1; head=h1; h3=h1->next; h4=h2->next; while(h3!=NULL && h4!=NUL

f(n)=1,当n=0时f(n)=nf(n/2) 当n>0时要求写出求f(n)的非递归算法int f(int n){ int st[MaxLen][3]; int top=1; while(n>0) {  st[top][2]=n;  n=n/2;  top++; } if(n==0) {  st[top][1]=1; } whi

#include#include#define MaxLen 20typedef char elemtype;typedef struct node{ elemtype data[MaxLen]; int front,rear;}squeue;void init(squeue *sq){ sq->front=0; sq->rear=0;}

#include#includeusing namespace std;typedef int elemtype;typedef struct node{ elemtype data; struct node *next;}nodetype;nodetype *create(){ cout nodetype *head,*p,*s; p=

题目：编写一个算法，对值递增有序的单链表进行以下操作：若表中存在值为x的节点，则将它从表中删除，否则，就往表中插入一个值为x的节点，并保持值递增有序的性质不变（假设表中没有值相同的元素）nodetype *f(nodetype *head,elemtype x){ nodetype *p=head->next,*q,*s; q=(nodetype *)malloc(sizeof(n

一、判断链表是否存在环，办法为：设置两个指针(fast, slow)，初始值都指向头，slow每次前进一步，fast每次前进二步，如果链表存在环，则fast必定先进入环，而slow后进入环，两个指针必定相遇。(当然，fast先行头到尾部为NULL，则为无环链表)程序如下：bool IsExitsLoop(slist* head){    slist * slow = hea

#include#includeusing namespace std;typedef int elemtype;typedef struct node{ elemtype data; struct node *left,*next;}nodetype;nodetype *create(){ cout nodetype *head,*p,*s

typedef char elemtype;typedef struct node{ elemtype data; struct node *left,*right;}BTree;BTree *create(){ BTree *s,*t,*p[MaxLen]; int i=0,j; elemtype ch; while(cin>>ch && ch!='h

#includeusing namespace std;void add(int n,int m,int s[],int a[],int t,int T[]){  int i,j; cout for(i=0;i  cin>>s[i]; cout for(i=0;i  cin>>a[i]; for(i=0;i  T[i]=0; t=5; for

nodetype *minus(nodetype *h1,nodetype *h2){ nodetype *p,*q; p=h1->next; q=h2->next; if(p==NULL)  return h2; if(q==NULL)  return h1; while(q!=NULL) {  p=h1->next;  int i=1;  w

typedef struct node{ char data; struct node *next;}cnode;cnode *create(){ cout cnode *head,*p,*s; p=(cnode *)malloc(sizeof(cnode)); head=p; s=p; s->next=NULL; char n; whi

将队列的首尾相连构成一个环形区域，当在第n个位置进行元素的入队操作之后，下一个地址就“翻转”为1.采用这种方式的队列成为循环队列。    以入队为例要进行如下操作：       1.将队尾序号tail加1，即tail=tail+1       2.若tail=n+1,则tail=1;       其实以上两步可以用下面的表达式来表示：tail=(tail+1)%n.

nodetype *revers(nodetype *head){ nodetype *p,*q,*s; p=head->next; if(p==NULL || p->next==NULL)  return head; int i=1; q=p->next; while(q!=NULL) {  s=q->next;  q->next=p;  if(i