实验1
8576 顺序线性表的基本操作
#include<stdio.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int
typedef struct
{
int *elem;
int length;
int listsize;
}SqList;
int InitList_Sq(SqList &L)
{
// 算法2.3，构造一个空的线性表L，该线性表预定义大小为LIST_INIT_SIZE
// 请补全代码
L.elem=new ElemType[LIST_INIT_SIZE];
if(!L.elem) return 1;
L.length=0;
L.listsize=LIST_INIT_SIZE;
return 0;
}
int Load_Sq(SqList &L)
{
// 输出顺序表中的所有元素
int i;
if(L.length==0) printf("The List is empty!"); // 请填空
else
{
printf("The List is: ");
for(i=0;i<L.length;i++) printf("%d ",L.elem[i]); // 请填空
}
printf("\n");
return OK;
}
int ListInsert_Sq(SqList &L,int i,int e)
{
// 算法2.4，在顺序线性表L中第i个位置之前插入新的元素e
// i的合法值为1≤i≤L.length +1
// 请补全代码
if(i<1||i>L.length+1)
return 1;
else
{
for(int j=L.length-1;j>=i-1;j--)
{
L.elem[j+1]=L.elem[j];
}
L.elem[i-1]=e;
++L.length;
return 0;
}
}
int ListDelete_Sq(SqList &L,int i, int &e)
{
// 算法2.5,在顺序线性表L中删除第i个位置的元素，并用e返回其值
// i的合法值为1≤i≤L.length
// 请补全代码
if(i<1||i>L.length)
return 1;
else
{
e=L.elem[i-1];
for(int j=i-1;j<=L.length-1;j++)
{
L.elem[j]=L.elem[j+1];
}
L.length--;
return 0;
}
}
int main()
{
SqList T;
int a, i;
ElemType e, x;
if(!InitList_Sq(T)) // 判断顺序表是否创建成功
{
printf("A Sequence List Has Created.\n");
}
while(1)
{
printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
scanf("%d",&a);
switch(a)
{
case 1: scanf("%d%d",&i,&x);
if(ListInsert_Sq(T,i,x)) printf("Insert Error!\n"); // 执行插入函数，根据返回值判断i值是否合法
else printf("The Element %d is Successfully Inserted!\n", x);
break;
case 2: scanf("%d",&i);
if(ListDelete_Sq(T,i,e)) printf("Delete Error!\n"); // 执行删除函数，根据返回值判断i值是否合法
else printf("The Element %d is Successfully Deleted!\n", e);
break;
case 3: Load_Sq(T);
break;
case 0: return 1;
}
}
}
8577 合并顺序表
#include <stdio.h>
#include <malloc.h>
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
#define ElemType int
#define LIST_INIT_SIZE 100
typedef int Status;
typedef struct
{
int *elem;
int length;
int listsize;
}SqList;
Status InitList_Sq(SqList &L)
{
L.elem=new ElemType[LIST_INIT_SIZE];
if(!L.elem) return ERROR;
L.length=0;
L.listsize=LIST_INIT_SIZE;
return OK;
}
Status CreatList_Sq(SqList &L,int n)
{
if(!InitList_Sq(L)) return ERROR;
for(int i=0;i<n;i++)
{
cin>>L.elem[i];
L.length++;
}
return OK;
}
Status PrintList_Sq(SqList L)
{
if(L.length==0)
cout<<'The List is empty!';
int i;
for(i=0;i<L.length;i++)
{
cout<<L.elem[i]<<' ';
}
cout<<endl;
return OK;
}
Status MergeList_Sq(SqList LA,SqList LB,SqList &LC)
{
int *pa,*pb,*pc,*pa_last,*pb_last;
LC.length=LA.length+LB.length;
LC.elem=new ElemType[LC.length];
pc=LC.elem;
pa=LA.elem;
pb=LB.elem;
pa_last=LA.elem+LA.length-1;
pb_last=LB.elem+LB.length-1;
while(pa<=pa_last&&pb<=pb_last)
{
if((*pa)<=(*pb))
*pc++=*pa++;
else
*pc++=*pb++;
}
while(pa<=pa_last) *pc++=*pa++;
while(pb<=pb_last) *pc++=*pb++;
}
int main()
{
SqList A,B,C;
int n,m;
InitList_Sq(A);
InitList_Sq(B);
InitList_Sq(C);
cin>>n;
CreatList_Sq(A,n);
cin>>m;
CreatList_Sq(B,m);
cout<<"List A:";
PrintList_Sq(A);
cout<<"List B:";
PrintList_Sq(B);
MergeList_Sq(A,B,C);
cout<<"List C:";
PrintList_Sq(C);
return 0;
}
8578 顺序表逆置
#include<stdio.h>
#include<malloc.h>
#include<iostream>
#define OK 1
#define ERROR 0
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define ElemType int
using namespace std;
typedef int Status;
typedef struct
{
int *elem;
int length;
int listsize;
}SqList;
Status InitList_Sq(SqList &L)
{ // 算法2.3
// 构造一个空的线性表L。
L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if (!L.elem) return OK; // 存储分配失败
L.length = 0; // 空表长度为0
L.listsize = LIST_INIT_SIZE; // 初始存储容量
return OK;
} // InitList_Sq
Status ListInsert_Sq(SqList &L, int i, ElemType e)
{ // 算法2.4
// 在顺序线性表L的第i个元素之前插入新的元素e，
// i的合法值为1≤i≤ListLength_Sq(L)+1
ElemType *p;
if (i < 1 || i > L.length+1) return ERROR; // i值不合法
if (L.length >= L.listsize) { // 当前存储空间已满，增加容量
ElemType *newbase = (ElemType *)realloc(L.elem,
(L.listsize+LISTINCREMENT)*sizeof (ElemType));
if (!newbase) return ERROR; // 存储分配失败
L.elem = newbase; // 新基址
L.listsize += LISTINCREMENT; // 增加存储容量
}
ElemType *q = &(L.elem[i-1]); // q为插入位置
for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p;
// 插入位置及之后的元素右移
*q = e; // 插入e
++L.length; // 表长增1
return OK;
} // ListInsert_Sq
Status ListDelete_Sq(SqList &L, int i, ElemType &e)
{ // 算法2.5
// 在顺序线性表L中删除第i个元素，并用e返回其值。
// i的合法值为1≤i≤ListLength_Sq(L)。
ElemType *p, *q;
if (i<1 || i>L.length) return ERROR; // i值不合法
p = &(L.elem[i-1]); // p为被删除元素的位置
e = *p; // 被删除元素的值赋给e
q = L.elem+L.length-1; // 表尾元素的位置
for (++p; p<=q; ++p) *(p-1) = *p; // 被删除元素之后的元素左移
--L.length; // 表长减1
return OK;
} // ListDelete_Sq
Status CreatList_Sq(SqList &L,int n)
{
if(!InitList_Sq(L)) return ERROR;
for(int i=0;i<n;i++)
{
cin>>L.elem[i];
L.length++;
}
return OK;
}
Status PrintList_Sq(SqList L)
{
for(int i=0;i<L.length;i++)
{
cout<<L.elem[i]<<' ';
}
cout<<endl;
return OK;
}
Status DaozhiList_Sq(SqList &L)
{
ElemType p;
for(int n=0;n<L.length/2;n++)
{
p=L.elem[n];
L.elem[n]=L.elem[L.length-1-n];
L.elem[L.length-1-n]=p;
}
return OK;
}
int main()
{
ElemType n;
SqList T;
InitList_Sq(T);
cin>>n;
CreatList_Sq(T,n);
cout<<"The List is:";
PrintList_Sq(T);
DaozhiList_Sq(T);
cout<<"The turned List is:";
PrintList_Sq(T);
return 0;
}
8579 链式线性表的基本操作
#include<stdio.h>
#include<malloc.h>
#include<iostream>
#define ERROR 0
#define OK 1
#define ElemType int
using namespace std;
typedef struct LNode
{
int data;
struct LNode *next;
}LNode,*LinkList;
int CreateLink_L(LinkList &L,int n){
// 创建含有n个元素的单链表
LinkList p,q;
int i;
ElemType e;
L = new LNode;
L->next = NULL; // 先建立一个带头结点的单链表
q = L;
for (i=0; i<n; i++) {
scanf("%d", &e);
p = new LNode; // 生成新结点
p->data=e;
p->next=NULL;
q->next=p;
q=p;// 请补全代码
}
return OK;
}
int LoadLink_L(LinkList &L){
// 单链表遍历
LinkList p = L->next;
if(!p)printf("The List is empty!"); // 请填空
else
{
printf("The LinkList is:");
while(p!=NULL) // 请填空
{
printf("%d ",p->data);
p=p->next; // 请填空
}
}
printf("\n");
return OK;
}
int LinkInsert_L(LinkList &L,int i,ElemType e){
// 算法2.9
// 在带头结点的单链线性表L中第i个位置之前插入元素e
// 请补全代码
LinkList p=L,s;
int j=0;
while(p&&j<i-1)
{
p=p->next;
j++;
}
if(!p||j>i-1) return ERROR;
s=new LNode;
s->data=e;
s->next=p->next;
p->next=s;
return OK;
}
int LinkDelete_L(LinkList &L,int i, ElemType &e){
// 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并用e返回其值
// 请补全代码
LinkList p=L,t;
int j=0;
while(p->next&&j<i-1)
{
p=p->next;
j++;
}
if(!p->next||j>i-1) return ERROR;
t=p->next;
e=t->data;
p->next=t->next;
delete t;
return OK;
}
int main()
{
LinkList T;
int a,n,i;
ElemType x, e;
printf("Please input the init size of the linklist:\n");
scanf("%d",&n);
printf("Please input the %d element of the linklist:\n", n);
if(CreateLink_L(T,n)) // 判断链表是否创建成功，请填空
{
printf("A Link List Has Created.\n");
LoadLink_L(T);
}
while(1)
{
printf("1:Insert element\n2:Delete element\n3:Load all elements\n0:Exit\nPlease choose:\n");
scanf("%d",&a);
switch(a)
{
case 1: scanf("%d%d",&i,&x);
if(!LinkInsert_L(T,i,x)) printf("Insert Error!\n"); // 判断i值是否合法，请填空
else printf("The Element %d is Successfully Inserted!\n", x);
break;
case 2: scanf("%d",&i);
if(!LinkDelete_L(T,i,e)) printf("Delete Error!\n"); // 判断i值是否合法，请填空
else printf("The Element %d is Successfully Deleted!\n", e);
break;
case 3: LoadLink_L(T);
break;
case 0: return 1;
}
}
}
8580 合并链表
#include<stdio.h>
#include<malloc.h>
#define ERROR 0
#define OK 1
#define ElemType int
#include<iostream>
using namespace std;
typedef int Status;
typedef struct LNode
{
int data;
struct LNode *next;
}LNode,*LinkList;
Status CreatLinkList_L(LinkList &L,int n)
{
LinkList p,q;
ElemType e;
L=new LNode;
L->next=NULL;
q=L;
while(n--)
{
cin>>e;
p=new LNode;
p->data=e;
p->next=NULL;
q->next=p;
q=p;
}
return OK;
}
Status ListInsert_L(LinkList &L, int i, ElemType e) { // 算法2.9
// 在带头结点的单链线性表L的第i个元素之前插入元素e
LinkList p,s;
p = L;
int j = 0;
while (p && j < i-1) { // 寻找第i-1个结点
p = p->next;
++j;
}
if (!p || j > i-1) return ERROR; // i小于1或者大于表长
s = (LinkList)malloc(sizeof(LNode)); // 生成新结点
s->data = e; s->next = p->next; // 插入L中
p->next = s;
return OK;
} // LinstInsert_L
Status ListDelete_L(LinkList &L, int i, ElemType &e) { // 算法2.10
// 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
LinkList p,q;
p = L;
int j = 0;
while (p->next && j < i-1) { // 寻找第i个结点，并令p指向其前趋
p = p->next;
++j;
}
if (!(p->next) || j > i-1) return ERROR; // 删除位置不合理
q = p->next;
p->next = q->next; // 删除并释放结点
e = q->data;
free(q);
return OK;
} // ListDelete_L
Status MergeList_L(LinkList LA,LinkList LB,LinkList &LC)
{
LinkList la,lb,lc;
LC=new LNode;
la=LA->next;
lb=LB->next;
lc=LC=LA;
while(la&&lb)
{
if(la->data<lb->data)
{
lc->next=la;
lc=la;
la=la->next;
}
else
{
lc->next=lb;
lc=lb;
lb=lb->next;
}
}
if(la&&!lb) {lc->next=la;}
if(!la&&lb) lc->next=lb;
return OK;
}
Status PrintList_L(LinkList L)
{
LinkList p=L;
if(p->next==NULL) return ERROR;
while(p->next)
{
p=p->next;
cout<<p->data<<' ';
}
cout<<endl;
return OK;
}
int main()
{
int n;
LinkList A,B,C;
cin>>n;
CreatLinkList_L(A,n);
cin>>n;
CreatLinkList_L(B,n);
cout<<"List A:";
PrintList_L(A);
cout<<"List B:";
PrintList_L(B);
MergeList_L(A,B,C);
cout<<"List C:";
PrintList_L(C);
return 0;
}
19080 反转链表
#include <iostream>//C++
using namespace std;
struct LNode
{
int data;
LNode * next;
};
void createList(LNode * &L,int n)
{
//< 尾插法创建单链表
LNode *r, *p;
r=L=new LNode;//< 创建头结点
L->next=NULL;
for(int i=1; i<=n; i++)
{
p=new LNode;
cin>>p->data;
p->next=NULL;
r->next=p;
r=p;
}
}
void trv(LNode * L)
{
//< 一个简单的链表遍历函数，供编程过程中测试使用
L=L->next;
while(L)
{
cout<<L->data<<' ';
L=L->next;
}
}
void reverseList(LNode * &L)
{
LNode *pre=NULL,*cur=L->next,*nex=NULL;
while(cur)
{
nex=cur->next;
cur->next=pre;
pre=cur;
cur=nex;
}
L->next=pre;
}
int main()
{
int n;
LNode *L;
cin>>n;
createList(L,n);
reverseList(L);
trv(L);
return 0;
}
实验2
8583 顺序栈的基本操作
#include<malloc.h>
#include<stdio.h>
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100 // 存储空间初始分配量
#define STACKINCREMENT 10 // 存储空间分配增量
typedef int SElemType; // 定义栈元素类型
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
struct SqStack
{
SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
SElemType *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间，以元素为单位
}; // 顺序栈
Status InitStack(SqStack &S)
{
// 构造一个空栈S，该栈预定义大小为STACK_INIT_SIZE
// 请补全代码
S.base=new SElemType[STACK_INIT_SIZE];
if(!S.base) return ERROR;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
Status Push(SqStack &S,SElemType e)
{
// 在栈S中插入元素e为新的栈顶元素
// 请补全代码
if(S.top-S.base==STACK_INIT_SIZE) return ERROR;
*S.top++=e;
return OK;
}
Status Pop(SqStack &S,SElemType &e)
{
// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
// 请补全代码
if(!(S.top==S.base))
{
e=*--S.top;
return OK;
}
else return ERROR;
}
Status GetTop(SqStack S,SElemType &e)
{
// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
// 请补全代码
if(S.top==S.base) return ERROR;
e=*(S.top-1);
return OK;
}
int StackLength(SqStack S)
{
// 返回栈S的元素个数
// 请补全代码
return (S.top-S.base);
}
Status StackTraverse(SqStack S)
{
// 从栈顶到栈底依次输出栈中的每个元素
SElemType *p = S.top; //请填空
if(S.top==S.base)printf("The Stack is Empty!"); //请填空
else
{
printf("The Stack is: ");
while(p!=S.base) //请填空
{
p--;//请填空
printf("%d ", *p);
}
}
printf("\n");
return OK;
}
int main()
{
int a;
SqStack S;
SElemType x, e;
if(InitStack(S)) // 判断顺序表是否创建成功，请填空
{
printf("A Stack Has Created.\n");
}
while(1)
{
printf("1:Push \n2:Pop \n3:Get the Top \n4:Return the Length of the Stack\n5:Load the Stack\n0:Exit\nPlease choose:\n");
scanf("%d",&a);
switch(a)
{
case 1: scanf("%d", &x);
if(!Push(S,x)) printf("Push Error!\n"); // 判断Push是否合法，请填空
else printf("The Element %d is Successfully Pushed!\n", x);
break;
case 2: if(!Pop(S,e)) printf("Pop Error!\n"); // 判断Pop是否合法，请填空
else printf("The Element %d is Successfully Poped!\n", e);
break;
case 3: if(!GetTop(S,e))printf("Get Top Error!\n"); // 判断Get Top是否合法，请填空
else printf("The Top Element is %d!\n", e);
break;
case 4: printf("The Length of the Stack is %d!\n",StackLength(S)); //请填空
break;
case 5: StackTraverse(S); //请填空
break;
case 0: return 1;
}
}
}
8584 循环队列的基本操作
#include<malloc.h>
#include<stdio.h>
#define OK 1
#define ERROR 0
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
typedef int QElemType;
#define MAXQSIZE 100 // 最大队列长度(对于循环队列，最大队列长度要减1)
typedef struct
{
QElemType *base; // 初始化的动态分配存储空间
int front; // 头指针,若队列不空,指向队列头元素
int rear; // 尾指针,若队列不空,指向队列尾元素的下一个位置
}SqQueue;
Status InitQueue(SqQueue &Q)
{
// 构造一个空队列Q，该队列预定义大小为MAXQSIZE
// 请补全代码
Q.base=new QElemType[MAXQSIZE];
if(!Q.base) return ERROR;
Q.front=Q.rear=0;
return OK;
}
Status EnQueue(SqQueue &Q,QElemType e)
{
// 插入元素e为Q的新的队尾元素
// 请补全代码
if((Q.rear+1)%MAXQSIZE==Q.front)
return ERROR;
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1)%MAXQSIZE;
return OK;
}
Status DeQueue(SqQueue &Q, QElemType &e)
{
// 若队列不空, 则删除Q的队头元素, 用e返回其值, 并返回OK; 否则返回ERROR
// 请补全代码
if(Q.front==Q.rear) return ERROR;
e=Q.base[Q.front];
Q.front=(Q.front+1)%MAXQSIZE;
return OK;
}
Status GetHead(SqQueue Q, QElemType &e)
{
// 若队列不空，则用e返回队头元素，并返回OK，否则返回ERROR
// 请补全代码
if(Q.front==Q.rear) return ERROR;
e=Q.base[Q.front];
return OK;
}
int QueueLength(SqQueue Q)
{
// 返回Q的元素个数
// 请补全代码
return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}
Status QueueTraverse(SqQueue Q)
{
// 若队列不空，则从队头到队尾依次输出各个队列元素，并返回OK；否则返回ERROR.
int i;
i=Q.front;
if(Q.rear==Q.front)printf("The Queue is Empty!"); //请填空
else{
printf("The Queue is: ");
while(i!=Q.rear) //请填空
{
printf("%d ",Q.base[i] ); //请填空
i = (i+1)%MAXQSIZE; //请填空
}
}
printf("\n");
return OK;
}
int main()
{
int a;
SqQueue S;
QElemType x, e;
if(InitQueue(S)) // 判断顺序表是否创建成功，请填空
{
printf("A Queue Has Created.\n");
}
while(1)
{
printf("1:Enter \n2:Delete \n3:Get the Front \n4:Return the Length of the Queue\n5:Load the Queue\n0:Exit\nPlease choose:\n");
scanf("%d",&a);
switch(a)
{
case 1: scanf("%d", &x);
if(!EnQueue(S,x)) printf("Enter Error!\n"); // 判断入队是否合法，请填空
else printf("The Element %d is Successfully Entered!\n", x);
break;
case 2: if(!DeQueue(S,e)) printf("Delete Error!\n"); // 判断出队是否合法，请填空
else printf("The Element %d is Successfully Deleted!\n", e);
break;
case 3: if(!GetHead(S,e))printf("Get Head Error!\n"); // 判断Get Head是否合法，请填空
else printf("The Head of the Queue is %d!\n", e);
break;
case 4: printf("The Length of the Queue is %d!\n",QueueLength(S)); //请填空
break;
case 5: QueueTraverse(S); //请填空
break;
case 0: return 1;
}
}
}
8585 栈的应用——进制转换
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define OK 1
#define ERROR 0
#define StackInitSize 100
typedef int Status;
typedef int SElemType;
using namespace std;
struct SqStack
{
SElemType *base;
SElemType *top;
int stacksize;
};
Status CreateStack_S(SqStack &S)
{
S.base=new SElemType[StackInitSize];
if(!S.base) return ERROR;
S.top=S.base;
S.stacksize=StackInitSize;
return OK;
}
Status PoPStack_S(SqStack &S,SElemType x)
{
if(S.top-S.base==StackInitSize) return ERROR;
*S.top++=x;
return OK;
}
Status PushStack_S(SqStack &S,SElemType e)
{
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}
Status StackTraverse(SqStack S)
{
// 从栈顶到栈底依次输出栈中的每个元素
SElemType *p = S.top; //请填空
if(S.top==S.base)return ERROR;
while(p!=S.base) //请填空
{
p--;//请填空
printf("%d", *p);
}
return OK;
}
void Transnum8(SqStack &S,int n)
{
int a,b;
while(n)
{
a=n%8;
PoPStack_S(S,a);
n=n/8;
}
StackTraverse(S);
}
int main()
{
SqStack S;
SElemType x,e;
CreateStack_S(S);
int n;
cin>>n;
Transnum8(S,n);
return 0;
}
8586 括号匹配检验
typedef char SElemType;
#include"malloc.h"
#include"stdio.h"
#include"math.h"
#include"stdlib.h" // exit()
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
#define STACK_INIT_SIZE 10 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量
struct SqStack
{
SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
SElemType *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间，以元素为单位
}; // 顺序栈
Status InitStack(SqStack &S)
{
S.base=new SElemType[STACK_INIT_SIZE];
if(!S.base) return ERROR;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
Status StackEmpty(SqStack S)
{
if(S.top==S.base)
return OK;
else
return 0;
}
Status Push(SqStack &S,SElemType &e)
{
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}
Status Pop(SqStack &S,SElemType e)
{
if(S.top-S.base==S.stacksize) return ERROR;
*S.top++=e;
return OK;
}
void check()
{ // 对于输入的任意一个字符串，检验括号是否配对
SqStack s;
SElemType ch[80],*p,e;
if(InitStack(s)) // 初始化栈成功
{
//printf("请输入表达式\n");
gets(ch);
p=ch;
while(*p) // 没到串尾
{
switch(*p)
{
case '(':
case '[':Pop(s,*p++);
break; // 左括号入栈，且p++
case ')':
case ']':if(!StackEmpty(s)) // 栈不空
{
Push(s,e); // 弹出栈顶元素
if(*p==')'&&e!='('||*p==']'&&e!='[')
// 弹出的栈顶元素与*p不配对
{
printf("isn't matched pairs\n");
exit(ERROR);
}
else
{
p++;
break; // 跳出switch语句
}
}
else // 栈空
{
printf("lack of left parenthesis\n");
exit(ERROR);
}
default: p++; // 其它字符不处理，指针向后移
}
}
if(StackEmpty(s)) // 字符串结束时栈空
printf("matching\n");
else
printf("lack of right parenthesis\n");
}
}
int main()
{
check();
}
8587 行编辑程序
typedef char SElemType;
#include"malloc.h"
#include"stdio.h"
#include"math.h"
#include"stdlib.h" // exit()
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
#define STACK_INIT_SIZE 100 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量
struct SqStack
{
SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
SElemType *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间，以元素为单位
}; // 顺序栈
Status InitStack(SqStack &S)
{ // 构造一个空栈S
S.base=new SElemType[STACK_INIT_SIZE];
if(!S.base) return ERROR;
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
Status StackEmpty(SqStack S)
{ // 若栈S为空栈，则返回TRUE，否则返回FALSE
if(S.top==S.base) return TRUE;
else return FALSE;
}
Status ClearStack(SqStack &S)
{ // 把S置为空栈
S.top=S.base;
return OK;
}
Status DestroyStack(SqStack &S)
{ // 销毁栈S，S不再存在
free(S.base);
S.base=NULL;
S.top=NULL;
S.stacksize=0;
return OK;
}
Status Push(SqStack &S,SElemType e)
{ // 插入元素e为新的栈顶元素
if(S.top-S.base==S.stacksize) return ERROR;
*S.top++=e;
return OK;
}
Status Pop(SqStack &S,SElemType &e)
{ // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(S.top!=S.base)
{
e=*--S.top;
return OK;
}
else return ERROR;
}
Status StackTraverse(SqStack S,Status(*visit)(SElemType))
{ // 从栈底到栈顶依次对栈中每个元素调用函数visit()。
// 一旦visit()失败，则操作失败
while(S.top>S.base)
visit(*S.base++);
printf("\n");
return OK;
}
Status visit(SElemType c)
{
printf("%c",c);
return OK;
}
void LineEdit()
{ // 利用字符栈s，从终端接收一行并送至调用过程的数据区。算法3.2
SqStack s;
char ch,c;
int n,i;
InitStack(s);
scanf("%d",&n);
ch=getchar();
for(i=1;i<=n;i++)
{ ch=getchar();
while(ch!='\n')
{
switch(ch)
{
case '#':Pop(s,c);
break; // 仅当栈非空时退栈
case '@':ClearStack(s);
break; // 重置s为空栈
default :Push(s,ch); // 有效字符进栈
}
ch=getchar(); // 从终端接收下一个字符
}
StackTraverse(s,visit); // 将从栈底到栈顶的栈内字符输出
ClearStack(s); // 重置s为空栈
}
DestroyStack(s);
}
int main()
{
LineEdit();
return 0;
}
18938 汉诺塔问题
//汉诺塔问题，打印的是整个的移动过程
#include <stdio.h>
void hanoi(int n, char A, char B, char C)//n个圈圈在柱子A上，借助柱子B，移动到柱子C上
{
if (n == 1)//如果A柱子上只有一个圈圈，直接移动到B上
printf("%c->%d->%c\n", A,n, B);
else
{
hanoi(n - 1, A, C, B);//将A柱子上的n-1个圈圈，借助柱子B，移动到柱子C上
printf("%c->%d->%c\n", A, n,B);//将A柱子上的最后一个圈圈移动到柱子B上
hanoi(n - 1, C, B, A);//将C柱子上的n-1个圈圈，借助柱子A，移动到柱子B上
}
}
int main()
{
int n;
char a, b, c;
scanf("%d %c %c %c",&n,&a,&b,&c);
if (n >= 20||n<=0) {
return 0;
}
hanoi(n, a, b, c);
return 0;
}
18937 阿克曼(Ackmann)函数
#include<iostream>
#include<algorithm>
using namespace std;
int akm(int m,int n){
if(m==0){
return n+1;
}else if(m>0&&n==0){
return akm(m-1,1);
}else if(m>0&&n>0){
return akm(m-1,akm(m,n-1));
}
}
int main(){
int n,m;
cin>>m>>n;
cout<<akm(m,n);
return 0;
}
实验3
8591 计算next值
#include "stdio.h"
#include "stdlib.h"
#include "iostream"
#define MAXSTRLEN 255 // 用户可在255以内定义最大串长
typedef unsigned char SString[MAXSTRLEN+1]; // 0号单元存放串的长度
void get_next(SString T,int next[]){
// 算法4.7
// 求模式串T的next函数值并存入数组next
// 请补全代码
int i=1;
next[1]=0;
int j=0;
while(i<=T[0])
{
if(j==0||T[i]==T[j])
{
++i;++j;
next[i]=j;
}
else j=next[j];
}
}
int main(){
int next[MAXSTRLEN];
SString S;
int n,i,j;
char ch;
scanf("%d",&n); // 指定要验证NEXT值的字符串个数
ch=getchar();
for(i=1;i<=n;i++)
{
ch=getchar();
for(j=1;j<=MAXSTRLEN&&(ch!='\n');j++) // 录入字符串
{
S[j]=ch;
ch=getchar();
}
S[0]=j-1; // S[0]用于存储字符串中字符个数
get_next(S,next);
printf("NEXT J is:");
for(j=1;j<=S[0];j++)
printf("%d",next[j]);
printf("\n");
}
return 0;
}
8592 KMP算法
#include "stdio.h"
#include "stdlib.h"
#include "iostream"
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASLBLE -1
#define OVERFLOW -2
#define MAXSTRLEN 255 //用户可在255以内定义最大串长
typedef unsigned char SString[MAXSTRLEN+1]; //0号单元存放串的长度
void get_next(SString T,int next[]){
// 算法4.7
// 求模式串T的next函数值并存入数组next
// 请补全代码
int i=1,j=0;
next[1]=0;
while(i<=T[0])
{
if(j==0||T[i]==T[j])
{
++i;++j;
next[i]=j;
}
else
j=next[j];
}
}
int Index_KMP(SString S,SString T,int pos,int next[]){
// 算法4.6
// 利用模式串T的next函数求T在主串S中第pos个字符之后的位置
// KMP算法。请补全代码
int i=pos;
int j=1;
while(i<=S[0]&&j<=T[0])
{
if(j==0||S[i]==T[j])
{
++j;
++i;
}
else
j=next[j];
}
if(j>T[0]) return i-T[0];
else return 0;
}
int main()
{
SString T,S;
int i,j,n;
char ch;
int pos;
int next[MAXSTRLEN];
scanf("%d",&n); // 指定n对需进行模式匹配的字符串
ch=getchar();
for(j=1;j<=n;j++)
{
ch=getchar();
for( i=1;i<=MAXSTRLEN&&(ch!='\n');i++) // 录入主串
{
S[i]=ch;
ch=getchar();
}
S[0]=i-1; // S[0]用于存储主串中字符个数
ch=getchar();
for( i=1;i<=MAXSTRLEN&&(ch!='\n');i++) // 录入模式串
{
T[i]=ch;
ch=getchar();
}
T[0]=i-1; // T[0]用于存储模式串中字符个数
get_next(T,next);
pos=Index_KMP(S,T,1,next); // 请填空
printf("%d\n",pos);
}
}
18769 不完整的排序
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
#include<iostream>
using namespace std;
int b[100005];
int main()
{
int n;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
int m;
scanf("%d",&m);
int* a=new int[m];
for(int j=0;j<m;j++)
{
cin>>a[j];
}
int *p,*q;
p=a;
q=p+m-1;
while(p<q)
{
while(*p<0&&p<q) p++;
while(*q>0&&p<q) q--;
int temp=*p;
*p=*q;
*q=temp;
}
for(int t=0;t<m;t++)
{
printf("%d ",a[t]);
}
printf("\n");
}
return 0;
}
实验4
8606 二叉树的构建及遍历操作
#include "stdio.h"
#include "malloc.h"
#include <iostream>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
using namespace std;
typedef char ElemType;
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild,*rchild;//左右孩子指针
} BiTNode,*BiTree;
Status CreateBiTree(BiTree &T) { // 算法6.4
// 按先序次序输入二叉树中结点的值（一个字符），’#’字符表示空树，
// 构造二叉链表表示的二叉树T。
char ch;
scanf("%c",&ch);
if (ch=='#') T = NULL;
else {
if (!(T = (BiTNode *)malloc(sizeof(BiTNode)))) return ERROR;
T->data=ch; // 生成根结点
CreateBiTree(T->lchild); // 构造左子树
CreateBiTree((T->rchild)); // 构造右子树
}
return OK;
} // CreateBiTree
Status PreOrderTraverse( BiTree T) {
// 前序遍历二叉树T的递归算法
//补全代码,可用多个语句
if(T)
{
cout<<T->data;
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
} // PreOrderTraverse
Status InOrderTraverse( BiTree T) {
// 中序遍历二叉树T的递归算法
//补全代码,可用多个语句
if(T)
{
InOrderTraverse(T->lchild);
cout<<T->data;
InOrderTraverse(T->rchild);
}
} // InOrderTraverse
Status PostOrderTraverse( BiTree T) {
// 后序遍历二叉树T的递归算法
//补全代码,可用多个语句
if(T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data;
}
} // PostOrderTraverse
int main() //主函数
{
BiTree T;
CreateBiTree(T);
PreOrderTraverse(T);
cout<<endl;
InOrderTraverse(T);
cout<<endl;
PostOrderTraverse(T);
cout<<endl;
return 0;
//补充代码
}//main
17121 求二叉树各种节点数
#include "stdio.h"
#include "malloc.h"
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#include <iostream>
using namespace std;
typedef int Status;
typedef char ElemType;
typedef struct BiTNode{
ElemType data;
struct BiTNode *lchild,*rchild;//左右孩子指针
} BiTNode,*BiTree;
Status CreateBiTree(BiTree &T,int &count0,int &count1,int &count2) { // 算法6.4
// 按先序次序输入二叉树中结点的值（一个字符），’#’字符表示空树，
// 构造二叉链表表示的二叉树T。
char ch;
scanf("%c",&ch);
if (ch=='#') T = NULL;
else {
if (!(T = (BiTNode *)malloc(sizeof(BiTNode)))) return ERROR;
T->data=ch; // 生成根结点
CreateBiTree(T->lchild,count0,count1,count2); // 构造左子树
CreateBiTree(T->rchild,count0,count1,count2); // 构造右子树
if(!T->lchild&&!T->rchild) count0++;
else if((T->lchild&&!T->rchild)||(!T->lchild&&T->rchild)) count1++;
else if(T->lchild&&T->rchild) count2++;
}
return OK;
} // CreateBiTree
int main() //主函数
{
BiTree T;
int count0=0,count1=0,count2=0;
CreateBiTree(T,count0,count1,count2);
cout<<count2<<endl;
cout<<count1<<endl;
cout<<count0<<endl;//补充代码
return 0;
}//main
18924 二叉树的宽度
#include<stdio.h>
#include<math.h>
#include<iostream>
using namespace std;
int level[55];
struct tree
{
int p;
int l;
int r;
}tree[100];
void t(int p,int c)
{
tree[c].p=p;
if(!tree[p].l)
tree[p].l=c;
else
tree[p].r=c;
}
void h(int root,int c)
{
level[c]++;
if(tree[root].l)
h(tree[root].l,c+1);
if(tree[root].r)
h(tree[root].r,c+1);
}
int main()
{
int n;
int x,y;
int ans=0,root=0;
cin>>n;
for(int i=1;i<n;i++)
{
cin>>x>>y;
t(x,y);
}
for(int i=1;i<=n;i++)
{
if(tree[i].p==0)
{
root=i;
break;
}
}
h(root,1);
for(int i=1;i<=50;i++)
{
if(level[i]>ans)
ans=level[i];
}
cout<<ans;
return 0;
18724 二叉树的遍历运算
#include<iostream>
#include<cstring>
using namespace std;
#define maxn 10000
char pre[maxn],in[maxn],post[maxn];
void Post(char pre[],char in[],int len,int root)
{
if(len<=0) return;
int i=0;
while(in[i]!=pre[0]) i++;
Post(pre+1,in,i,root-(len-i-1)-1);
Post(pre+1+i,in+i+1,len-i-1,root-1);
post[root]=pre[0];
}
int main()
{
cin>>pre>>in;
int len=strlen(in);
Post(pre,in,len,len-1);
cout<<post<<endl;
return 0;
}
18923 二叉树的直径
#include<stdio.h>
#include<malloc.h>
#include<iostream>
using namespace std;
typedef int ElemType;
struct BiTNode
{
ElemType data;
BiTNode *lchild,rchild;
}BiTNode,*BiTree;
void insertData(BiTree &T,ElemType data)
{
BiTree p=new BiTNode;
P->data=data;
p->lchild=NUll;
p->rchild=NUll;
if(T==NULL)
T=p;
else
{
if(T->lchild==NULL)
T->lchild=p;
else T->rchild=p;
}
}
void PreOrderSearch(BiTree T,ElemType x,BiTree &result)
{
if(T)
{
if(T->data==x) result=T;
PreOrderSearch(T->lchild,x,result);
PreOrderSearch(T->rchild,x,result);
}
}
int maxcount=0;
int maxDepth(BiTree &T)
{
if(T==NULL)
return 0;
int leftdepth=maxDepth(T->lchild);
int rightdepth=maxDepth(T->rchild);
int count=leftdepth+rightdepth;
maxcount=count>maxcount?count:maxcount;
return leftdepth>rightdepth?leftdepth+1:rightdepth+1;
}
int main()
{
BiTree P=NULL;
int n;
cin>>n;
n--;
insertData(P,1);
while(n--)
{
ElemType x,y;
cin>>x>>y;
BiTree res=NULL;
PreOrderSearch(P,x,res);
insertData(res,y);
}
maxDepth(P);
cout>>maxcount;
return 0;
}
实验5
8610 顺序查找
#include"malloc.h" /* malloc()等
#include"stdio.h"
#include"stdlib.h"
typedef int ElemType;
typedef struct /*静态查找表的顺序存储结构 */
{
ElemType *elem; /* 数据元素存储空间基址，建表时按实际长度分配，0号单元留空 */
int length; /* 表长度 */
}SSTable;
void Creat_Seq(SSTable &ST,int n)
{ /* 操作结果: 构造一个含n个数据元素的静态顺序查找表ST(数据来自数组r) */
int i,temp;
ST.elem=(ElemType *)malloc((n+1) * sizeof(ElemType)); /* 动态生成n个数据元素空间(0号单元不用) */
if(!(ST).elem)
{
printf("ERROR\n");
exit(0);
} /*内存分配失败结束程序*/
for(i=1;i<=n;i++)
{
scanf("%d",&temp);
*(ST.elem+i)=temp; /* 依次赋值给ST */
}
ST.length=n;
}
int Search_Seq(SSTable &ST,ElemType key)
{ /* 在顺序表ST中顺序查找其关键字等于key的数据元素。若找到，则函数值为 */
/* 该元素在表中的位置，否则为0。算法9.1 */
int i=ST.length;
ST.elem[0]=key;
while(ST.elem[i]!=key)
{
i--;
}
return i;
}
int main()
{
SSTable ST;
int loc,key;
int n;
scanf("%d",&n);
Creat_Seq(ST,n);
//printf("Please input the key value：");
scanf("%d",&key);
loc = Search_Seq(ST,key);
if(loc!=0)
printf("The element position is %d.\n",loc);
else
printf("The element is not exist.\n");
}
8621 二分查找
#include<iostream>
using namespace std;
int n,key,mid;
int binary(int a[],int n)
{
int low=0,high=n;
while(low<=high)
{
mid=(low+high)/2;
if(a[mid]==key)
return 1;
else if(key<a[mid])
high=mid-1;
else low=mid+1;
}
return 0;
}
int main()
{
cin>>n;
int a[n+5];
for(int i=0;i<n;i++)
cin>>a[i];
cin>>key;
if(binary(a,n)) cout<<"The element position is "<<mid<<'.';
else cout<<"The element is not exist.";
}
8622 哈希查找
#include"malloc.h" /* malloc()等 */
#include"stdlib.h" /* exit() */
#include"stdio.h"
#define EQ(a,b) ((a)==(b))
#define SUCCESS 1
#define UNSUCCESS 0
#define NULLKEY -1 /*哈希表无元素时值为-1*/
typedef int ElemType;
int length;
typedef struct
{
ElemType *elem; /* 数据元素存储基址，动态分配数组 */
int count; /* 当前数据元素个数 */
}HashTable;
void InitHashTable(HashTable *H)
{ /* 操作结果: 构造一个长度为length的哈希表,length为全局变量 */
int i;
(*H).count=0; /* 当前元素个数为0 */
(*H).elem=(ElemType*)malloc(length*sizeof(ElemType));
if(!(*H).elem)
exit(0); /* 存储分配失败 */
for(i=0;i<length;i++)
(*H).elem[i]=NULLKEY; /* 未填记录的标志 */
}
unsigned Hash(ElemType K)
{ /* 一个简单的哈希函数*/
return 3*k%length;
}
void collision(int *p) /*线性探测再散列 */
{ /* 开放定址法处理冲突 */
*p=(*p+1)%length;
}
int SearchHash(HashTable H,ElemType K,int *p,int *c)
{ /* 在开放定址哈希表H中查找关键码为K的元素,若查找成功,以p指示待查数据 */
/* 元素在表中位置,并返回SUCCESS;否则,以p指示插入位置,并返回UNSUCCESS */
/* c用以计冲突次数，其初值置零，供建表插入时参考。算法9.17 */
*p=Hash(K); /* 求得哈希地址 */
while(H.elem[*p]!=NULLKEY&&!EQ(K,H.elem[*p]))
{ /* 该位置中填有记录,并且关键字不相等 */
(*c)++;
if(*c<length)
collision(p); /* 求得下一探查地址p */
else
break;
}
if EQ(K,H.elem[*p])
return SUCCESS; /* 查找成功，p返回待查数据元素位置 */
else
return UNSUCCESS; /* 查找不成功(H.elem[p].key==NULLKEY)，p返回的是插入位置 */
}
int InsertHash(HashTable *H,ElemType e)
{ /* 查找不成功时插入数据元素e到开放定址哈希表H中，并返回查找长度 */
int c,p;
c=0;
if(SearchHash(*H,e,&p,&c)) /* 表中已有与e有相同关键字的元素 */
printf("哈希表中已有元素%d。\n",e);
else{ /* 插入e */
(*H).elem[p]=e;
++(*H).count;
}
return c+1; /*查找长度为冲突次数加1*/
}
void TraverseHash(HashTable H)
{ /* 按哈希地址的顺序打印哈希表，无元素位置用X表示 */
int i;
printf("HashTable Address:0～%d\n",length-1);
for(i=0;i<length;i++)
if(H.elem[i]==NULLKEY) /* 有数据 */
printf("X ");
else
printf("%d ",H.elem[i]);
printf("\n");
}
main()
{
float i=0,j=0;
ElemType e;
HashTable H;
//printf("Input Table length:");
scanf("%d",&length);
InitHashTable(&H);
//printf("Input key words sequence, -1 conclusion input：");
scanf("%d",&e);
while(e!=-1)
{
j ++; /*j记录输入元素个数*/
i = i + InsertHash(&H,e); /*i记录查找长度的和*/
scanf("%d",&e);
}
TraverseHash(H);
printf("Average search length=%f\n",i/j);
}
实验6
直接插入排序
#include<iostream>
using namespace std;
void InsertSort(int *a,int n)
{
for(int i=2;i<=n;i++)
{
if(a[i]<a[i-1])
{
a[0]=a[i];
a[i]=a[i-1];
int j;
for(j=i-1;a[0]<a[j-1];j--)
{
a[j]=a[j-1];
}
a[j]=a[0];
for(int k=1;k<=n;k++)
{
cout<<a[k]<<' ';
}
cout<<endl;
}
}
}
int main()
{
int a[1000];
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
InsertSort(a,n);
}
折半插入排序
#include<iostream>
using namespace std;
void BinSort(int *a,int n)
{
for(int i=2;i<=n;i++)
{
int low=1,high=i-1,mid;
a[0]=a[i];
while(low<=high)
{
mid=(low+high)/2;
if(a[0]<a[mid]) high=mid-1;
else low=mid+1;
}
for(int j=i;j>high+1;j--) a[j]=a[j-1];
a[high+1]=a[0];
for(int k=1;k<=n;k++) cout<<a[k]<<' ';
cout<<endl;
}
}
int main()
{
int n,a[10000];
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
BinSort(a,n);
return 0;
}
shell排序
#include<iostream>
using namespace std;
void ShellSort(int a[],int n)
{
int temp;
int d=n/2;
while(d)
{
for(int i=d;i<n;i++)
{
temp=a[i];
int j=i;
while(j>=d&&temp<a[j-d])
{
a[j]=a[j-d];
j-=d;
}
a[j]=temp;
}
d=d/2;
for(int k=0;k<n;k++)
cout<<a[k]<<' ';
cout<<endl;
}
}
int main()
{
int n,a[100000];
cin>>n;
for(int i=0;i<n;i++)
cin>>a[i];
ShellSort(a,n);
}
冒泡排序
#include<iostream>
using namespace std;
void BubbleSort(int *a,int n)
{
int end=n-1;
bool flag=1;
while(end>0&&flag)
{
flag=false;
for(int i=1;i<=end;i++)
{
if(a[i]>a[i+1])
{
int temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
flag=true;
}
}
end--;
for(int k=1;k<=n;k++)
cout<<a[k]<<' ';
cout<<endl;
}
}
int main()
{
int n,a[10000];
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
BubbleSort(a,n);
return 0;
}
快速排序
#include<iostream>
using namespace std;
int Part(int *a,int l,int r)
{
a[0]=a[l];
int q=a[l];
while(l<r)
{
while(a[r]>=q&&l<r) r--;
a[l]=a[r];
while(a[l]<=q&&l<r) l++;
a[r]=a[l];
}
a[l]=a[0];
return l;
}
void QSort(int *a,int l,int r,int len)
{
if(l<r)
{
int p=Part(a,l,r);
for(int k=1;k<=len;k++)
cout<<a[k]<<' ';
cout<<endl;
QSort(a,l,p-1,len);
QSort(a,p+1,r,len);
}
}
int main()
{
int n,a[10000];
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
QSort(a,1,n,n);
return 0;
}
简单选排
#include<iostream>
using namespace std;
void Ssort(int *a,int len)
{
for(int i=1;i<len;++i)
{
int k=i;
for(int j=i+1;j<=len;++j)
if(a[j]<a[k])
k=j;
int tmp=a[k];
a[k]=a[i];
a[i]=tmp;
for(int k=1;k<=len;++k)
cout<<a[k]<<' ';
cout<<endl;
}
}
int main()
{
int n,a[100000];
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i];
Ssort(a,n);
return 0;
}
堆排序
#include<iostream>
using namespace std;
void Adjust(int *a,int s,int len)
{
int rc=a[s];
for(int i=2*s;i<=len;i=i*2)
{
if(a[i]<a[i+1]&&i<len)
i++;
if(rc<a[i])
{
a[s]=a[i];
s=i;
}
}
a[s]=rc;
}
void CreatHeap(int *a,int len)
{
for(int i=len/2;i>0;i--)
{
Adjust(a,i,len);
}
}
void StackSort(int *a,int len)
{
CreatHeap(a,len);
for(int i=len;i>1;i--)
{
for(int k=1;k<=len;k++)
cout<<a[k]<<' ';
cout<<endl;
int temp=a[1];
a[1]=a[i];
a[i]=temp;
Adjust(a,1,i-1);
}
}
int main()
{
int n,a[100000];
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
StackSort(a,n);
for(int k=1;k<=n;k++)
cout<<a[k]<<' ';
return 0;
}
归并
#include<iostream>
using namespace std;
int n;
void Merge(int a[],int l,int m,int r)
{
int *p=new int [r-l+10];
int i=l,j=m+1,k=0;
while(i<=m&&j<=r)
{
if(a[i]>=a[j]) p[k++]=a[j++];
else p[k++]=a[i++];
}
while(i<=m) p[k++]=a[i++];
while(j<=r) p[k++]=a[j++];
for(i=l,k=0;i<=r;i++,k++)
{
a[i]=p[k];
}
delete[]p;
}
void group_two(int a[],int gap)
{
int i=1;
while(i+2*gap<n)
{
Merge(a,i,i+gap-1,i+2*gap-1);
i=i+2*gap;
}
if(i+gap-1<n) Merge(a,i,i+gap-1,n);
}
void Msort(int a[])
{
for(int gap=1;gap<n;gap*=2)
{
group_two(a,gap);
for(int k=1;k<=n;k++)
cout<<a[k]<<' ';
cout<<endl;
}
}
int main()
{
int a[10000];
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
}
Msort(a);
return 0;
}*/
实验7
图的存储结构
#include <iostream>
using namespace std;
#define num 100
int arr[num][num];
int main()
{
int a,b;
cin>>a>>b;
for(int i=0;i<b;i++)
{
int v1,v2;
cin>>v1>>v2;
arr[v1][v2]=1;
}
for(int i=1;i<=a;i++)
{
for(int j=1;j<=a;j++)
{
cout<<arr[i][j]<<' ';
}
cout<<endl;
}
return 0;
}*/
图的深度/广度遍历
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
int book[10000]={0};
vector<int>e[10000];
void dfs(int z)
{
cout<<(char)(z+'a')<<" ";
int len=e[z].size();
for(int i=0;i<len;i++)
{
int y=e[z][i];
if(book[y]==0)
{
book[y]=1;
dfs(y);
}
}
return ;
}
void bfs(int z)
{
queue<int>q;
q.push(z);
while(!q.empty())
{
int r=q.front();
q.pop();
cout<<(char)(r+'a')<<" ";
int len=e[r].size();
for(int i=0;i<len;i++)
{
int y=e[r][i];
if(book[y]==0)
{
book[y]=1;
q.push(y);
}
}
}
return;
}
int main()
{
int t;
cin>>t;
int n,m;
cin>>n>>m;
int temp;
for(int i=0;i<n;i++)
{
char x;
cin>>x;
}
for(int i=0;i<m;i++)
{
char x,y;
cin>>x>>y;
int a=(char)(x-'a');
int b=(char)(y-'a');
if(i==0)
temp=a;
if(t<=1)
e[a].insert(e[a].begin(),b);
else
{
e[a].insert(e[a].begin(),b);
e[b].insert(e[b].begin(),a);
}
}
book[temp]=1;
//选择遍历
//dfs(temp);
bfs(temp);
}
155
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
