|
|
#include<stdio.h>
void swap(int *a,int *b)
{
int tmp;
tmp=*a;
*a=*b;
*b=tmp;
}
void quicksort(int k[],int s,int t)
{
int i,j;
if(s<t)
{
i=s;
j=t+1;
while(1)
{
do i++;
while(!(k[s]>=k[i] || i==t));//重复执行i++操作
do j--;
while(!(k[s]<=k[j] || j==s));//重复执行j--操作
if(i<j)
swap(&k[i],&k[j]); //交换k[i]和k[j]的位置
else
break;
}
swap(&k[s],&k[j]); //交换基准元素与k[j]的位置
quicksort(k,s,j-1); //递归排序基准元素前面的子序列
quicksort(k,j+1,t); //递归排序基准元素后面的子序列
}
}
int main()
{
int k[10]={2,5,6,3,7,8,0,9,12,1},i;
printf("The orginal data array is\n");
for(i=0;i<10;i++)
printf("%d ",k[i]);
quicksort(k,0,9); //从大到小排序
printf("\nThe result of quick sorting for the array is\n");
for(i=0;i<10;i++)
printf("%d ",k[i]);
return 0;
}
//希尔排序算法思想：缩小增量gap->划分序列->将每个子序列排序
#include<stdio.h>
void shellsort(int k[],int n)
{
int i,j,flag,gap=n;
int tmp;
while(gap>1)
{
gap=gap/2;
do{
flag=0;
for(i=1;i<=n-gap;i++)
{
j=i+gap;
if(k[i]<k[j])
{
tmp=k[i];
k[i]=k[j];
k[j]=tmp;
flag=1;
}
}
}while(flag!=0);
}
}
int main()
{
int i,a[11]={-111,2,5,6,3,7,8,0,9,12,1};
printf("The orginal data array is\n");
for(i=1;i<=10;i++)
printf("%d ",a[i]);
shellsort(a,10);
printf("\nThe result of Shell's sorting for the array is\n");//从大到小排序
for(i=1;i<=10;i++)
printf("%d ",a[i]);
return 0;
}
#include<stdio.h>
int insertsort(int a[],int n)//直接排序法
{
int i,j;
for(i=2;i<=n;i++)
{
a[0]=a[i]; //a[0]作为临时变量存储a[i]
j=i-1;
while(j>0 && a[0]>a[j])//从大到小排列
a[j+1]=a[j--];
a[j+1]=a[0]; //将元素a[0]插入指定位置
}
return 0;
}
int main()
{
int i,a[11]={-111,2,5,6,3,7,8,0,9,12,1};//a[0]没有使用
printf("The orginal data array is\n");
for(i=1;i<=10;i++)
printf("%d ",a[i]);
insertsort(a,10);
printf("\nThe result of insertion sorting for the array is\n");
for(i=1;i<=10;i++)
printf("%d ",a[i]);
printf("\n");
return 0;
}
#include<stdio.h> //用先序序列创建一棵二叉树，并输出字符D位于二叉树的层数
#include<stdlib.h>
#include<conio.h>
typedef struct BiTNode
{
char data;
struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;
CreatBiTree(BiTree *T)
{
char c;
scanf("%c",&c);
if(c == ' ') *T=NULL; //如果输出的是空格，则表示创建的子树结束
else
{
*T=(BiTNode*)malloc(sizeof(BiTNode)); //创建根结点
(*T)->data=c; //向根结点中输入数据
CreatBiTree(&((*T)->lchild)); //递归地创建左子树
CreatBiTree(&((*T)->rchild)); //递归地创建右子树
}
}
//访问二叉树结点，输出包含D字符结点位于二叉树中的层数
visit(char c,int level)
{
if(c=='D')
printf("%c is at %d lever of BiTree\n",c,level);
}
PreOrderTraverse(BiTree T,int level)
{
if(T) //递归结束条件，T为空
{
visit(T->data,level);//访问根结点
PreOrderTraverse(T->lchild,level+1);
PreOrderTraverse(T->rchild,level+1);
}
}
int main()
{
int level=1;
BiTree T=NULL; //最开始T指向空
CreatBiTree(&T);
PreOrderTraverse(T,level);
getche();
return 0;
}
//队列的基本操作：实现一个链队列，任意输入一串字符，以@为结束标志，然后将队列中的元素逐一取出，打印在屏幕上
#include<stdio.h>
#include<stdlib.h>
#include<conio.h>
typedef char ElemType;
typedef struct QNode
{
ElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
QueuePtr front; //队头指针
QueuePtr rear; //队尾指针
}LinkQueue;
initQueue(LinkQueue *q) //创建一个头结点，队头队尾指针指向该结点
{
q->front=q->rear=(QueuePtr)malloc(sizeof(QNode));
if(!q->front) exit(0);
q->front->next=NULL;
}
EnQueue(LinkQueue *q,ElemType e)
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
if(!q->front) exit(0);
p->data=e; //数据e入列
p->next=NULL;
q->rear->next=p;
q->rear=p;
}
DeQueue(LinkQueue *q,ElemType *e)//如果队列q不为空，删除q的队头元素，用e返回其值
{
QueuePtr p;
if(q->front==q->rear) return; //队列为空，返回
p=q->front->next;
*e=p->data;
q->front->next=p->next;
if(q->rear==p) q->rear=q->front;//如果队头就是队尾，则修改队尾指针
free(p);
}
int main()
{
ElemType e;
LinkQueue q;
initQueue(&q);
printf("Please input a string into a queue\n");
scanf("%c",&e);
while(e!='@')
{
EnQueue(&q,e);
scanf("%c",&e);
}
printf("The string into the queue is\n");
while(q.front!=q.rear)
{
DeQueue(&q,&e);
printf("%c",e);
}
printf("\n");
getche();
return 0;
}
//二进制转换为十进制数（利用栈的数据结构）
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<conio.h>
#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10
typedef char ElemType;
typedef struct{
ElemType *base;
ElemType *top;
int stacksize;
}sqStack;
initStack(sqStack *s) //创建一个栈
{
s->base=(ElemType*)malloc(STACK_INIT_SIZE*sizeof(ElemType));
if(!s->base) exit(0);
s->top=s->base;
s->stacksize=STACK_INIT_SIZE;
}
Push(sqStack *s,ElemType e){
if(s->top-s->base>=s->stacksize){
s->base=(ElemType*)realloc(s->base,(s->stacksize+STACKINCREMENT)*sizeof(ElemType));
if(!s->base) exit(0);
s->top=s->base+s->stacksize;
s->stacksize=s->stacksize+STACKINCREMENT;
}
*(s->top)=e;
s->top++;
}
Pop(sqStack *s,ElemType *e){
if(s->top==s->base) return;
*e=*--(s->top);
}
int StackLen(sqStack s){ //计算栈的当前容量
return (s.top-s.base);
}
int main()
{
ElemType c;
sqStack s; //栈
int len,i,sum=0;
printf("Please input a Binary digit\n");
initStack(&s);
//输入0/1字符表示的二进制数，以#结束
scanf("%c",&c);
while(c!='#')
{
Push(&s,c);
scanf("%c",&c);
}
getchar();
len=StackLen(s);
for(i=0;i<len;i++)
{
Pop(&s,&c);
sum=sum+(c-48)*pow(2,i);//c-48是为了得到该字符对应的0/1值，这是因为字符0的ASCII码为48
}
printf("Decimal is %d\n",sum);
getche();
return 0;
}
//清空一个栈 代码
ClearStack(sqStack *s)
{
s->top=s->base;
}
//销毁一个栈 代码
DestroyStack(sqStack *s)
{
int i,len;
len=s->stacksize;
for(i=0;i<len;i++)
{
free(s->base);
s->base++;
}
s->base=s->top=NULL;
s->stacksize=0;
}
- 描述
Fibonacci数列：0，1，1，2，3，5，8，13，21，…
从0开始，后续的数具有这样的性质：当前的数是其前面两个数之和。编写一个函数计算第n个Fibonacci数。规定:Fibonacci(1)=1，fibonacci(2)=1。 - 输入
第一行1个整数t，表示有t组数据。以下t行，每行一个整数n。 - 输出
共t行，对于每个n，输出第n个Fibonacci数（结果不超过long int的范围）。 - 样例输入
2 3 5 - 样例输出
2 5
int main()
{
int t,i=0;
int a[10];
scanf("%d",&t);
while(t--)
{
int pre=1,next=1,result=1;
scanf("%d",&a[i]);
while(a[i]>2)
{
a[i]--;
next=pre;
pre=result;
result=pre+next;
}
printf("%d\n",result);
i++;
}
return 0;
}
- 描述
“回文”是一种特殊的数或者文字短语。他们无论是顺读还是倒读，结果都一样。例如：12321， 55555，45554。读入一个5位整数，判断它是否是回文数。 - 输入
多组测试数据，每组一行，一个五位整数，数据以0结尾。 - 输出
对每组输入数据输出一行，如果输入数是回文数，输出“Yes.” ，否则输出 “No.” 。 - 样例输入
12345 12321 11111 0 - 样例输出
No. Yes. Yes.
源代码如下，注意循环长度为（length/2+1）。 #include<stdio.h>
#include<string.h>
#include <stdlib.h>
int main()
{
int n,length,i=0,c;
char str[6];
while(scanf("%d",&n)!=EOF)
{
if(n==0)
exit(1);
c=0;
sprintf(str,"%d",n);
length=strlen(str);
for(i=0;i<(length/2+1);i++)
{
if(str[i]==str[length-i-1])
c++;
else
break;
}
if(c==3)
printf("Yes.\n");
else
printf("No.\n");
}
return 0;
}
要求：从终端输入一组整数（大于10），以0作为结束标志，将这一组整数存放在一个链表中（结束标志0不包括在内），打印出该链表中的值。然后删除该链表的第5个元素，打印出删除后的结果。最后在内存中释放掉该链表。 源程序如下： #include<stdio.h>
#include<stdlib.h>
#include<conio.h>
typedef int ElemType;
typedef struct node{
ElemType data;
struct node *next;
}LNode,*LinkList;
LinkList GreatLinkList(int n){
LinkList p,r,list=NULL;
ElemType e;
int i;
for(i=1;i<=n;i++)
{
scanf("%d",&e);
p=(LinkList)malloc(sizeof(LNode));
p->data=e;
p->next=NULL;
if(!list)
list=p; //如果list为空，则说明本次生成的结点为第一个结点，将p赋给list
else
r->next=p;//否则将p赋给r->next，这里r永远指向原先链表的最后一个结点，也就是要插入结点的前一个结点
r=p;
}
return list;//返回链表头指针
}
void insertList(LinkList *list,LinkList q,ElemType e)
{
LinkList p;
p=(LinkList)malloc(sizeof(LNode));
p->data=e;
if(!*list){ //当链表为空时，将p赋给list，p的next域的值置为空
*list=p;
p->next=NULL;
}
else
{
p->next=q->next;//q为插入指针指向的结点
q->next=p;
}
}
void delLink(LinkList *list,LinkList q){
LinkList r;
if(q==*list)//如果删除第一个结点
{
*list=q->next;
free(q);
}
else //删除其他结点
{
for(r=*list;r->next!=q;r=r->next);//当q所指向的结点的前驱结点的指针未知时，需要先通过链表头指针list遍历链表，
//找到q的前驱结点的指针，并把该指针赋值给指针变量r
if(r->next!=NULL){
r->next=q->next;
free(q);
}
}
}
void destroyLinkList(LinkList *list){
LinkList p,q;
p=*list;
while(p)//循环释放掉每个链表结点
{
q=p->next;
free(p);
p=q;
}
*list=NULL;//将该链表完全置空，防止list变成野指针
}
void main()
{
int e,i;
LinkList l,q;
q=l=GreatLinkList(1);//创建链表一个结点，q和l指向该结点
scanf("%d",&e);
while(e) //循环输入数据，同时插入新生成的结点
{
insertList(&l,q,e);
q=q->next;
scanf("%d",&e);
}
q=l;
printf("The content of the linklist\n");
while(q) //输出链表中的内容
{
printf("%d ",q->data);
q=q->next;
}
q=l;
printf("\nDelete teh fifthe element\n");
for(i=0;i<4;i++)
{
q=q->next;
}//将指针q指向链表的第5个元素
delLink(&l,q);
q=l;
while(q)
{
printf("%d ",q->data);
q=q->next;
}
destroyLinkList(&l);
getche();//输入后立即从控制台取字符，不以回车为结束(带回显)
}
要求：顺序表初始长度为10，向顺序表中输入15个整数，并打印出来；再删除顺序表中的第5个元素，打印出删除后的结果。 #include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#define MaxSize 10
typedef int ElemType;
typedef struct{
int *elem;
int length;
int listsize;
} Sqlist;
//初始化一个顺序表
void initSqlist(Sqlist *L)
{
L->elem=(int*)malloc(MaxSize*sizeof(ElemType));
if(!L->elem) exit(0);
L->length=0;
L->listsize=MaxSize;
}
void InsertElem(Sqlist *L,int i,ElemType item){
ElemType *base,*insertPtr,*p;
if(i<1||i>L->length+1)exit(0);
if(L->length>=L->listsize)
{
base=(ElemType*)realloc(L->elem,(L->listsize+10)*sizeof(ElemType));
L->elem=base;
L->listsize=L->listsize+100;
}
insertPtr=&(L->elem[i-1]);
for(p=&(L->elem[L->length-1]);p>=insertPtr;p--)
*(p+1)=*p;
*insertPtr=item;
L->length++;
}
void DelElem(Sqlist *L,int i)
{
ElemType *delItem,*q;
if(i<1||i>L->length) exit(0);
delItem=&(L->elem[i-1]);
q=L->elem+L->length-1;
for(++delItem;delItem<=q;++delItem)*(delItem-1)=*delItem;
L->length--;
}
void main()
{
Sqlist l;
int i;
initSqlist(&l);
for(i=0;i<15;i++)
InsertElem(&l,i+1,i+1);
printf("\nThe content of the list is\n");
for(i=0;i<l.length;i++)
printf("%d",l.elem[i]);
DelElem(&l,5);
printf("\nDelete the fifth element\n");
for(i=0;i<l.length;i++)
printf("%d",l.elem[i]);
getche();
}
|