数据结构第二章代码

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <iterator>
#include <initializer_list>
#include <deque>
#include <list>
#include <array>
#include <forward_list>
#include <sstream>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <memory>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <type_traits>
#include <utility>
#include <tuple>
#include <bitset>
#include <regex>
#include <random>
#include <iomanip>
#include <ctime>
#include <cmath>
using namespace::std;
////
////clock_t start, stop;
////double duration;
////#define MAXN 10
////#define MAXK 1e7
////
////double f1(int n, double a[], double x)
////{
//// int i;
//// double p = a[0];
//// for (i = 1; i <= n; ++i)
//// {
//// p += a[i] * pow(x, i);
//// }
//// return p;
////}
////
////double f2(int n, double a[], double x)
////{
//// int i;
//// double p = a[n];
//// for (i = n; i >= 1; --i)
//// {
//// p = a[i - 1]+x*p;
//// }
//// return p;
////}
////
////void run(double(*p)(int, double *, double), double a[], int case_n)
////{
//// int i;
//// start = clock();
//// for (i = 0; i < MAXK; ++i)
//// p(MAXN - 1, a, 1.1);
//// stop = clock();
//// duration = ((double)(stop - start)) / CLK_TCK;
//// cout << "ticks= " << case_n << double(stop - start) << endl;
//// cout << "duration=" << duration << "s" << endl;
////}


clock_t start, stop;
double duration;


double f1(double x)
{
double ret=1;
int i;
for (i = 1; i <= 100; ++i)
ret += pow(x, i) / (double)(i);
return ret;
}


double f2(double x)
{
int i;
double a[101];
for ( i = 1; i <= 100; ++i)
a[i] = (double)(1.0000/ i);
a[0] = 1.0;
double p = a[100];
for (i = 100; i >= 1; --i)
p = p * x + a[i - 1];
return p;
}




int mysort(int list[], int left, int right, int aim)
{
static int judge = -1;
if (right-left>=0)
{
int middle = (left + right) / 2;
if (list[middle] == aim)
judge= 1;
if (left == right)
return -1;
else if (aim<list[middle])
mysort(list, left, middle, aim);
else if (aim>list[middle])
mysort(list, middle + 1, right, aim);
}
return judge;
}


int mysort2(int list[], int left, int right, int aim)
{
int middle;
while (left <=right)
{
middle = (left + right) / 2;
if (list[middle] == aim)
return 1;
if (left == right)
return -1;
else if (aim<list[middle])
{
right = middle;
}
else if (aim>list[middle])
{
left = middle + 1;
}
}
return -1;
}




double multiple(int min, int max, double x)
{
int middle;
double ret=1.0;
if (max >= min)
{
middle = (max + min) / 2;
if (min == max)
{
ret = x;
return ret;
}
ret = multiple(min, middle, x)*multiple(middle + 1, max, x);
}
return ret;
}


bool judge(int N)
{
int i;
for (i = 2; i <= sqrt(N); ++i)
{
if (N%i == 0)
return true;
}
return false;
}


struct Node;
typedef Node* PtrToNode;


struct Node {
Node() = default;
Node(int ata) :Data(ata) {


}
int Data;
PtrToNode Next;
};
typedef PtrToNode List;


struct DNode;
typedef DNode *PtrToDNode;
using ElementType = int;
struct DNode
{
ElementType Data;
PtrToDNode Next;
PtrToDNode Previous;
};






void InsertDNode(PtrToDNode p, PtrToDNode t)
{
t->Previous = p;
t->Next = p->Next;
p->Next->Previous = t;
p->Next = t;
}


PtrToNode Reverse(PtrToNode L)
{
PtrToNode Old_head, New_head, Temp;
Old_head = L;
New_head = nullptr;
while (Old_head)
{
Temp = Old_head->Next;
Old_head->Next = New_head;
New_head = Old_head;
Old_head = Temp;
}
L = New_head;
return L;
}
ElementType selectsortmiddle(ElementType a[], int n)
{
int i;
int j;
int maxpos;
ElementType max=0;
for (i = 0; i != n-1; ++i)
{
for (j = i + 1; j != n; ++j)
{
if (a[j] > max)
{
maxpos=j;
max = a[j];
}
}
ElementType temp;
temp = a[i];
a[i] = a[maxpos];
a[maxpos] = temp;
}
return a[(n - 1) / 2];
}


int factorial(int N)
{
if (N == 0)
return 1;
else
return N * factorial(N - 1);
}


void hannoitower(int n, int start, int goal, int temp)
{
if (n)
{
hannoitower(n - 1, start, temp, goal);
cout << "move disk" << n << " from " << start << " to " << goal<<endl;
hannoitower(n - 1, temp, goal, start);
}
}


int Sum(int n, int a)
{
static int sum;
if (n > 1)
sum = a * (1 + Sum(n - 1, a));
else sum = a;
return sum;
}


void show()
{
#define n 10


int a[n];
default_random_engine e(time(0));
uniform_int_distribution<int> u(0, 9);
for (auto i = 0; i != n; ++i)
a[i] = u(e);
for (auto i = 0; i != n; ++i)
cout << a[i] << ends;
cout << endl;
int m;
cout << "Enter the number that you would like for the left shift of the array" << endl;
cin >> m;
int b[n];
int j = 0;
for (int i = m; i != n; ++i, ++j)
{
b[j] = a[i];
}
int i = 0;
while (i != m)
{
b[j++] = a[i++];
}
for (auto k = 0; k != n; ++k)
cout << b[k] << ends;
}


double walk(double height)
{
double ret=0.0;
if (height >= 0.000001)
{
ret += height + 0.9*height + walk(0.9*height);
}
return ret;
}


double myf(double x, int m)
{
double ret=0.0;
if (m>=1)
{
ret = x * (1 + (-1) * myf(x, m- 1));
}
return ret;
}


int Allarrange(int m)
{
if (m >= 1)
{
return m * Allarrange(m - 1);
}
else
{
return 1;
}
}






int main(int argc,char *argv[])
{


for (auto i = 1; i != 20; ++i)
{
start = clock();
int j;
for(auto k=0;k!=10000;++k)
j = Allarrange(i);
stop = clock();
duration = (double)(stop - start) / CLK_TCK;
cout << j << "   " << duration << endl;
}
}