算法设计与分析第一次单元考核

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_32175379/article/details/73136272

第一次单元章节考核
要求：
（1）要求动态通过键盘在对话框或命令行输入，而后显示结果（输入输出用scanner或system.in），本次考试的输入不要采用JOptionPane的输入方式；
（2）程序检查过后点“提交”按钮，然后关机，走人！
注意：
（1）严格按照输入、输出的要求，否则一律0分，补考！！！
题目如下：
1. Ackerman函数的递归实现算法。
输入：输入两个数字，先输入n，后输入m。
输出：Ackerman函数计算后的值。
示例：输入：4 2，输出：16

Ackerman函数A(n，m)定义如下：
有两个独立的整型变量m、n：

C++
#include<iostream>
using namespace std;
int Ackerman(int n,int m)
{
    if (m==0&&n==1)
    {
        return 2;
    }
    if (m>=0&&n==0)
    {
        return 1;
    }
    if (m==0&&n>=2)
    {
        return n + 2;
    }
    if (m >=1 && n >= 1)
    {
        return Ackerman(Ackerman(n - 1,m), m - 1);
    }
    return 0;
}
int main()
{
    int n, m;
    cin >> n >> m;
    int c=Ackerman(n,m);
    cout << c;
    return 0;
}
2.全排列的递归实现算法。
输入：先输入要求输入的字符的个数，后依次输入（或随机生成）每个字符（不能仅仅是数字）。
输出：全排列的结果。
示例：输入：3  /  *  2，输出：/  *  2  /  2  *  *  /  2  *  2  /  2  *  /  2  /  *  

C++

#include <iostream>  

using namespace std;
int total = 0;
//交换函数  
inline void swapArray(char &a, char &b) //设置成内联函数运行更快
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}
//递归函数  
void fullPermutation(char fullArray [], int start, int end)
{
    //这里，既可以是">=",也可以是">",也可以是"=="  
    if (start ==end)
    {
        for (int i = 0; i<=end; i++){
            cout << fullArray[i];
        }
        cout << endl;
    }
    else
    {
        for (int i = start; i <= end; i++)
        {
            swapArray(fullArray[start], fullArray[i]);//交换  
            fullPermutation(fullArray, start + 1, end);
            swapArray(fullArray[start], fullArray[i]);//注意恢复原样  
        }
    }
}
int main()
{
    int n;
    cin >> n;
    char *arr = new char[n];
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    fullPermutation(arr, 0, n - 1);
delete[]arr;
    return 0;
}R的全排列可归纳递归定义如下：



3.整数划分的递归实现算法。
输入：输入整数划分的整数（只输入一次，即n==m）。
输出：输入整数的划分个数值。
示例：输入：7，输出：15

q(n,m)的如下递归关系定义如下：
正整数n的划分数p(n)=q(n,n)。 


C++
#include <iostream>  
using namespace std;
int q(int n,int m)
{
    if (n==1||m==1)
    {
        return 1;
    }
    if (n<m)
    {
        return q(n,n);
    }
    if (n==m)
    {
        return 1 + q(n,n-1);
    }
    if (n>m&&n>1&&m>1)
    {
        return q(n, m - 1) + q(n-m,m);
    }
}
int main()
{
    int n;
    cin >> n;
    int m = n;
    int c = q(n, m);
    cout << c;
    return 0;
}

4.二分搜索的递归实现算法。
输入：先输入进行二分搜索元素的个数，然后按大小依次输入（或随机生成，然后排序）每个数字，最后输入要求搜索的元素。
输出：要求搜索元素的下标（下标从0开始！）。
示例：输入：6    1 5 5 6 9 9    6，输出3

C++

#include <iostream>  
using namespace std;

//递归
int search(int arr[],int l,int r,int key)
{
    int min = (l + r) / 2;
    if (key==arr[min])
    {
        return min;
    }
    else if (key<arr[min])
    {
        return search(arr,l,min-1,key);
    }
    else if (key>arr[min])
    {
        return search(arr, min + 1, r, key);
    }
    else
    {
        return -1;
    }
}

//非递归
/*int search(int arr[], int l, int r, int key)
{

    while (l<=r)
    {
        int min = (l + r) / 2;
        if (key == arr[min])
        {
            return min;
        }
        else if (key<arr[min])
        {
            r = min - 1;
        }
        else if (key>arr[min])
        {
            l = min + 1;
        }
        else
        {
            return -1;
        }
    }

}*/
int main()
{
    int n;//个数
    cin >> n;
    int *arr = new int[n];//大小为n的数组
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    int key;//要搜索的元素
    cin >> key;
    cout<<search(arr,0,n-1,key);
    delete[] arr;
    return 0;
}




第二次单元章节考核
要求：
（1）要求动态通过键盘在对话框或命令行输入，而后显示结果（输入输出用scanner或system.in），本次考试的输入不要采用JOptionPane的输入方式；
（2）程序检查过后点“提交”按钮，然后关机，走人！
注意：
（1）严格按照输入、输出的要求，否则一律0分，补考！！！

题目如下：
1.写出菲波拉契数列自底向上的非递归动态规划算法或自顶向下的递归动态规划算法（备忘录方法）。
输入：输入一个数字。                   
输出：输出为Fibonacci数列的值。
示例：输入：5  ，输出：8

Fibonacci数列可以递归地定义为： 

JAVA:
public static int Fibonacci(int n)
    {
        if (n==0||n==1) {
            return 1;
        }
        if (n>1) {
            return Fibonacci(n-1)+Fibonacci(n-2);
        }
        return -1;
    }
    public static void main(String[] args)
    {
        int n;
        helloworld h=new helloworld();
        Scanner s=new Scanner(System.in);
        n=s.nextInt();
        System.out.println(h.Fibonacci(n));
    }

C++:

#include<iostream>
using namespace std;
int Fibonacci(int n)//递归
{
    if (n==0||n==1)
    {
        return 1;
    }
    if (n>1)
    {
        return Fibonacci(n - 1) + Fibonacci(n-2);
    }
    return -1;
}
int sum = 0;
int Fibonacci1(int n)//非递归
{
    int one = 1;
    int two = 1;
    int sum = 0;
    for (int i = 1; i < n; i++)
    {
        sum = one + two;
        two = one;
        one = sum;
    }
    return sum;
}
int main()
{
    int n;
    cin >>  n;
    cout << Fibonacci1(n);
    return 0;
}
2.合并排序的递归实现算法。
输入：先输入进行合并排序元素的个数，然后依次随机输入（或随机生成）每个数字。
输出：元素排序后的结果，数字之间不加任何标识符。
示例：输入：8  11  1  2  4  8  6  15  8，输出：1  2  4  6  8  8  11  15
#include<iostream>
using namespace std;
//合并排序/归并排序
template<typename T>
void __mergeSort(T arr[], int l, int mid, int r)
{
    // 经测试,传递aux数组的性能效果并不好
    //T aux[r - l + 1];
    T *aux = new T[r - l + 1];
    for (int i = l; i <= r; i++)
        aux[i - l] = arr[i];//赋值 

    int i = l, j = mid + 1;
    for (int k = l; k <= r; k++){

        if (i > mid)
        {
            arr[k] = aux[j - l]; j++;
        }
        else if (j > r)
        {
            arr[k] = aux[i - l]; i++;
        }
        else if (aux[i - l] < aux[j - l])
        {
            arr[k] = aux[i - l]; i++;
        }
        else
        {
            arr[k] = aux[j - l]; j++;
        }
    }
    delete[]aux;
}
template<typename T>
void MergeSort(T arr[], int l, int r)
{
    if (l >= r)
    {
        return;
    }
    int mid = (r + l) / 2;
    MergeSort(arr, l, mid);//先将这个运行到底             ①
    MergeSort(arr, mid + 1, r);//这个，mid不是那个例如数组大小为6，mid=3那个mid，而是上步①结束时的mid
    __mergeSort(arr, l, mid, r);//这个排序，排的是第一对（1边1个），在排第二对。。。然后下一轮第一对（1边2个）相排.。。
}
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    MergeSort(arr, 0, n-1);
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }
    delete[]arr;
    return 0;
}
3.快速排序的递归实现算法。
输入：先输入进行合并排序元素的个数，然后依次随机输入（或随机生成）每个数字。
输出：元素排序后的结果。
示例：输入：8  9  1  2  4  8  6  15  8，输出：1  2  4  6  8  8  9  15

C++
/*#include<iostream>
using namespace std;
void QuickSort(int arr[],int l,int r)
{
    if (l>=r)
    {
        return;
    }
    int i = l;
    int j = r;
    int v = arr[i];
    while (i<j)
    {
        while (i<j&&arr[j]>=v)
        {
            j--;
        }
        arr[i] = arr[j];
        while (i< j&&arr[i]<=v)
        {
            i++;
        }
        arr[j] = arr[i];
    }
    arr[i] = v;
    QuickSort(arr,l,i-1);//缩小范围，快排左边的
    QuickSort(arr,i+1,r); //快排右边的

}
int main()
{
    int n;
    cin >> n;
    int *arr = new int[n];
    for (int i = 0; i < n; i++)
    {
        cin >> arr[i];
    }
    QuickSort(arr,0,n-1);
    for (int i = 0; i < n; i++)
    {
        cout << arr[i] << " ";
    }
    return 0;
}*/



JAVA答案
import java.util.Scanner;
public class Main {

    //------------------------------Ackerman函数-------------------------------------
    /*public static int Ackerman(int n,int m)
    {
        if (m==0&&n==1) {
            return 2;
        }
        if (m>=0&&n==0) {
            return 1;
        }
        if (m==0&&n>=2) {
            return n+2;
        }
        if (m>=1&&n>=1) {
            return Ackerman(Ackerman(n-1, m), m-1);
        }
        return -1;
    }
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        int a,b;
        a=s.nextInt();
        b=s.nextInt();
        suanfa1 h=new suanfa1();
        int c=h.Ackerman(a, b);
        System.out.println(c);
    }*/
    //-------------------------------全排列---------------------------------
    /*public static void  SwapArr(char arr[],int a,int b) {
        char temp;
        temp=arr[a];
        arr[a]=arr[b];
        arr[b]=temp;
    }
    public static void  AllSort(char[]arr,int start,int end) {
        if (start==end) {
            for (int i = 0; i <= end; i++) {
                System.out.print(arr[i]);
            }
            System.out.println();
        }else {
            for (int i = start; i <=end; i++) {
                SwapArr(arr, start, i);
                AllSort(arr, start+1, end);
                SwapArr(arr, start, i);
            }
        }
    }
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        suanfa1 h=new suanfa1();
        int n;
        n=s.nextInt();
        char arr[]=new char[n];
        for (int i = 0; i < n; i++) {
            arr[i]=s.next().charAt(0);
        }
        h.AllSort(arr, 0, n-1);

//      System.out.println(c);
    }*/
    //-----------------------------整数划分------------------------------------------
    /*public static int q(int n,int m) {
        if (n==1||m==1) {
            return 1;
        }
        if (n<m) {
            return q(n, n);
        }
        if (n==m) {
            return 1+q(n, n-1);
        }
        if (n>m&&m>1) {
            return q(n, m-1)+q(n-m, m);
        }
        return -1;
    }
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        suanfa1 h=new suanfa1();
        int n;
        n=s.nextInt();
        int m=n;
        System.out.println(h.q(n, m));
    }*/
    //------------------------------二分查找---------------------------------------
    /*public static int search(int arr[],int l,int r,int key) {
        int min=(l+r)/2;
        if (key==arr[min]) {
            return min;
        }else if (key<arr[min]) {
            return search(arr, l, min-1, key);
        }else if (key>arr[min]) {
            return search(arr, min+1, r, key);
        }
        else {
            return -1;
        }
    }
public static void QuickSort(int arr[],int l,int r) {
        if (l>=r) {
            return;
        }
        int i=l,j=r;
        int v=arr[i];
        while (i<j) {
            while (i<j&&arr[j]>=v) {
                j--;
            }
            arr[i]=arr[j];
            while (i<j&&arr[i]<=v) {
                i++;
            }
            arr[j]=arr[i];
        }
        arr[i]=v;
        QuickSort(arr, l, i-1);
        QuickSort(arr, i+1, r);
    }

    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        suanfa1 h=new suanfa1();
        int n;
        n=s.nextInt();
        int arr[]=new int[n];
        for (int i = 0; i < n; i++) {
            arr[i]=s.nextInt();
        }
        int key=s.nextInt();
    QuickSort(arr, 0, n-1);
        System.out.println(h.search(arr, 0, n-1, key));

    }*/
    //----------------------------归/合并排序------------------------------------
    /*public  static void  MergeSort(int arr[],int l,int r) {
        if (l>=r) {
            return ;
        }
        int min=(l+r)/2;
        MergeSort(arr, l, min);
        MergeSort(arr, min+1, r);
        _mergesort(arr,l,min,r);
    }
    public static void _mergesort(int arr[],int l,int mid,int r) {
        int aux[]=new int[r-l+1];
        for (int i = l; i <= r; i++) {
            aux[i-l]=arr[i];
        }
        int i=l,j=mid+1;
        for (int k = l; k <= r; k++) {
            if (i>mid) {
                arr[k]=aux[j-l];
                j++;
            }else if(j>r){
                arr[k]=aux[i-l];
                i++;
            }else if (aux[i-l]<aux[j-l]) {
                arr[k]=aux[i-l];i++;
            }else  {
                arr[k]=aux[j-l];j++;
            }
        }
    }
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        suanfa1 h=new suanfa1();
        int n;
        n=s.nextInt();
        int arr[]=new int[n];
        for (int i = 0; i < n; i++) {
            arr[i]=s.nextInt();
        }
        h.MergeSort(arr, 0, n-1);
        //System.out.println(h.search(arr, 0, n-1, key));
        for (int i = 0; i < n; i++) {
            if (i==n-1) {
                System.out.print(arr[i]);
            }
            else {
                System.out.print(arr[i]+" ");
            }

        }
    }*/
    //---------------------------快排--------------------------------------
    public static void QuickSort(int arr[],int l,int r) {
        if (l>=r) {
            return;
        }
        int i=l,j=r;
        int v=arr[i];
        while (i<j) {
            while (i<j&&arr[j]>=v) {
                j--;
            }
            arr[i]=arr[j];
            while (i<j&&arr[i]<=v) {
                i++;
            }
            arr[j]=arr[i];
        }
        arr[i]=v;
        QuickSort(arr, l, i-1);
        QuickSort(arr, i+1, r);
    }
    public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
        suanfa1 h=new suanfa1();
        int n;
        n=s.nextInt();
        int arr[]=new int[n];
        for (int i = 0; i < n; i++) {
            arr[i]=s.nextInt();
        }
        h.QuickSort(arr, 0, n-1);
        for (int i = 0; i < n; i++) {
            if (i==n-1) {
                System.out.print(arr[i]);
            }
            else {
                System.out.print(arr[i]+" ");
            }

        }
    }
}