课堂作业总结性实验

创建两个有序链表L1,L2来表达多项式，然后相加得到L3

思路：首先，先定义结点类型，创建初始化函数（在初始化函数里面进行多项式的键盘系数和指数的输入，）然后建立合并函数（进行两个多项式链表的合成：通过指数的大小进行三种情况的判断：> < =.、进而进行相应的操作，）最终在主函数里进行调用。

#include <stdio.h>
#include <stdlib.h>
 typedef  struct LNode{
        float p;
        int e;
       struct LNode *next;
    }LNode,*LinkList;

    LinkList Init_List(){
    printf("请依次输入多项式的系数和指数(当输入结束时请输入0):\n");
    float p;
    int e;
    LinkList L,qa,s;
    L= (LinkList)malloc(sizeof(LNode));
    L->e=-1;
    L->p=-1;
    L->next=NULL;
    qa=L;
    while(1){
        scanf("%f", &p);
        scanf("%d", &e);
        if(p == 0 ){
            break;
        }
        s = (LinkList)malloc(sizeof(LNode));
        s->p = p;
        s->e = e;
        s->next = NULL;
        qa->next = s;
        qa = s;
    }
    return L;
    }


    LinkList add_List(LinkList firsta,LinkList firstb){
    LinkList firstc, ha, hb, pc, s;
    int a, b;
    float sum;
    firstc = (LinkList)malloc(sizeof(LNode));
    firstc->p = -1;
    firstc->e = -1;
    firstc->next = NULL;
    pc = firstc;

    ha = firsta->next;
    hb = firstb->next;
    while(ha!= NULL && hb != NULL){
        a = ha->e;
        b = hb->e;
        if(a < b){
            pc->next = ha;
            pc = pc->next;
            ha = ha->next;
        }else if(a > b){
            pc->next = hb;
            pc = pc->next;
            hb = hb->next;
        }else{
            sum = ha->p+ hb->p;
            if(sum != 0.0){
 
                ha->p= sum;
                pc->next = ha;
                pc = pc->next;
            }else{

  
                s = firsta;
                while(s != ha){
                    s = s->next;
                }
                s->next = ha->next;
            }
 
            ha = ha->next;
            hb = hb->next;
        }
    }

    if(ha != NULL){
        pc->next = ha;
    }

    if(hb != NULL){
        pc->next = hb;
    }
    return firstc;
    }
    void print_List(LinkList h){
    while(h != NULL){
        printf("%0.2f*X^%d + ", h->p, h->e);
        h=h->next;
    }
    printf("\n");

    }
int main()
{
    LinkList L1,L2,L3;
    L1=Init_List();
    L2=Init_List();
    L3=add_List(L1,L2);
    printf("两个多项式的和为: ");
    print_List(L3);
    return 0;
}

汉诺塔问题（三个碟子的搬运）

用数字1、2、3…来代替碟子得大小。在主函数里先在sa栈里进行放满碟子
首先定义结构体类型，里面有top及base和stacksize、初始化操作主要是进行内存空间得分配，然后是使该栈为空栈。
然后写出栈和入栈的函数（这里要注意判断栈满和栈空得判断，进而进行一些操作）、这些基础的操作函数是进行递归的基础操作。
然后写出一个使得碟子在两个柱子（即两个栈）进行移动的操作函数，
最后写出一个在三个栈移动的函数，主要思路是①将栈sa的n-1个盘子顺序移到栈sb②将栈sa的第n个盘子移到栈sc ③将栈sb的n-1个盘子顺序移到栈sc、如此递归循环，在函数开头加上判断条件，当碟子数为1时的操作。

对于三个主子可以相对于三个栈（因为汉诺塔规则：一个一个的移动，必须先移最上面的碟子）
当进行第一次递归时，可把底盘当作基座因为最大不影响移动，即n-1进行操作，即上一步的的n-1移动到B将最大的盘N移动到C，即再递归n-1 将B->C

#include <iostream>
#define MaxSize 20
#define TRUE 1
#define FALSE 0 // 可以方便定义
#define OK 1
#define ERROR -1
#define OVERFLOW -2
using namespace std;


typedef struct{
    int *base;
    int *top;
    int stacksize;
}SqStack;

int Init_Stack(SqStack &S){
    S.base=(int *)malloc(sizeof(int*)*MaxSize);
    if(!S.base) exit(OVERFLOW);
    S.top=S.base;
    S.stacksize=MaxSize;
    return OK;
}
int Push(SqStack &S, int e){
    if(S.top-S.base==S.stacksize)
        return ERROR;
    *S.top=e;
    S.top++;
    return OK;
}

int Pop(SqStack &S,int &e){
    if(S.base==S.top)
        return ERROR;
    --S.top;
    e=*S.top;
    return OK;
}

int PopTwo(SqStack &a,SqStack &b){

	int x;
	if(a.top ==NULL)
	{
		printf("栈空");
		return 0;
	}
	else
	{
	Pop(a,x); 
	Push(b,x); 
	return OK;
	}
}

void PopThree(int n,SqStack &sa,SqStack &sb,SqStack &sc){
    if(n == 1) 
		PopTwo(sa,sc);
	else
	{
		PopThree(n-1,sa,sc,sb); 
		PopTwo(sa,sc); 
		PopThree(n-1,sb,sc,sa); 
	}
}
int main()
{
    int n;
	scanf("%d", &n); // 汉诺塔的层数
	SqStack sa ;
	SqStack sb ;
	SqStack sc ;
	Init_Stack(sa);
	Init_Stack(sb);
	Init_Stack(sc);
	for(int i=n;i>0;i--){
        Pop(sa,i);
	}
	PopThree(n,sa,sb,sc);
    return 0;
}

将折半查找的非递归算法更改成递归算法

折半查找有一个条件，数据必须是有顺序性的，因此才能进行折半查找，当key小于mid所代表的值的时候，进行本身函数的调用，即进行low到mid-1的区间进行折半查找，当key大于mid所代表的值的时候，进行本身函数的调用，即进行mid+1到high的区间进行折半查找，以此类推当key==mid所代表的值的时候得到位置

#include<bits/stdc++.h>
using namespace std;
#define MAX 100

typedef struct{
    int key;
}RT;
typedef struct{
    RT *elem;
    int length;
}SSTable;

void Creat_SSTable(SSTable &ST){
    int n;
    ST.length=0;
    cout<<"请输入要创建的个数："<<endl;
    cin>>n;
    ST.elem=(RT*)malloc(sizeof(RT)*(n+1));
    for(int i=1;i<=n;i++){
        cout<<"请输入第"<<i<<"个"<<endl;
        cin>>ST.elem[i].key;
        ST.length++;
    }
}


int BinSearch(SSTable ST,int key,int low,int high){
    int mid;
    if(low>high){
        return 0;
    }else{
        mid=(low+high)/2;
        if(key<ST.elem[mid].key){return BinSearch(ST,key,low,mid-1);}
        else if(key>ST.elem[mid].key) {return BinSearch(ST,key,mid+1,high);}
        else return mid;
    }
}

int main(){
    SSTable ST;
    Creat_SSTable(ST);

    int k;
    cout<<"请输入要查询的数字："<<endl;
    cin>>k;
    cout<<"在"<<BinSearch(ST,k,1,ST.length)<<endl;

 return 0;
}