//#include <iostream>
//#include <vector>
//#include <stdint.h>
//#include <ctime>
//
//int main()
//{
// const uint32_t loop = 100000000000000;
// std::vector<int32_t> vec;
// clock_t timeStart = 0;
// for (uint32_t i = 0; i < loop; ++i)
// {
// vec.push_back(i);
// }
// // test time use
// // 1.by index
// timeStart = clock();
// uint64_t sum1 = 0;
// for (uint32_t i = 0; i < vec.size(); ++i)
// {
// sum1 += vec[i];
// }
// std::cout << sum1 << " " << clock() - timeStart << "clock" << std::endl;
//
// // 2.by iterator
// timeStart = clock();
// uint64_t sum2 = 0;
// for (std::vector<int32_t>::const_iterator it = vec.begin(); it != vec.end(); ++it)
// {
// sum2 += *it;
// }
// std::cout << sum2 << " " << clock() - timeStart << "clock" << std::endl;
// // 3.by auto iterator
// uint64_t sum3 = 0;
// timeStart = clock();
// for (auto it = vec.begin(); it != vec.end(); ++it)
// {
// sum3 += *it;
// }
// std::cout << sum3 << " " << clock() - timeStart << "clock" << std::endl;
//
// // 4.by for range
// uint64_t sum4 = 0;
// timeStart = clock();
// for (const auto& it : vec)
// {
// sum4 += it;
// }
// std::cout << sum4 << " " << clock() - timeStart << "clock" << std::endl;
//
// return 0;
//}
//
#include<iostream>
//import std;
import <vector>;
int main()
{
std::cout << "Import the STL library for best performance\n";
std::vector<int> v{ 5, 5, 5 };
}
//#include <vector>
//#include <iostream>
//using namespace std;
//int main()
//{
// vector<int> v{ 1,2,3,4 };
// v.clear();
// for(auto i:v)
// {
// cout << i;
// }
// cout << v.size()<<endl;
// cout << v.capacity()<<endl;
// v.shrink_to_fit();
// cout << v.capacity();
//}
//
//#include <map>
//#include <iostream>
//#include <string>
//using namespace std;
//int main()
//{
// map<string, int> a;
//
// a.insert(make_pair("jack", 18));
// a.insert(make_pair("tom", 38));
// a.insert(make_pair("chen", 28));
// a.insert(make_pair("fen", 13));
//
//
// auto it = a.begin();
// cout << (*it).first;
// cout << a.at("fen");
// a.erase(a.begin());
// a.insert(make_pair("admin", 8));
// cout << (*it).first;
//
//
//}
#include <iostream>
#include <vector>
using namespace std;
void fun(vector<int>::iterator it)
{
cout << *it;
}
int main()
{
vector<int> a {1,2,3,4,5,6,7};
vector<int>::iterator it = a.begin();
it++;
it += 1;
vector<int>::iterator it1 = it;
it1++;
cout << *it1;
fun(it1);
cout<<it - a.begin();
cout << distance(a.begin(), it);
}
#include <iostream>
#include <vector>
#include <list>
#include <ctime>
using namespace std;
class Message
{
};
int main()
{
vector<Message*> vt;
list<Message*> lt;
Message* msg = new Message();
time_t start = time(NULL);
for (int i = 0; i < 10000; ++i) {
vt.clear();
for (int j = 0; j < 100000; ++j) {
vt.push_back(msg);
}
}
time_t end = time(NULL);
cout << "vector spend time " << end - start << endl;
start = time(NULL);
for (int i = 0; i < 10000; ++i) {
lt.clear();
for (int j = 0; j < 100000; ++j) {
lt.push_back(msg);
}
}
end = time(NULL);
cout << "list spend time " << end - start << endl;
delete msg;
msg = NULL;
start = time(NULL);
for (int i = 0; i < 10000; ++i) {
typeof(vt.begin()) it = vt.begin();
while (it != vt.end()) {
msg = *it;
++it;
}
}
end = time(NULL);
cout << "vector spend time " << end - start << endl;
start = time(NULL);
for (int i = 0; i < 10000; ++i) {
typeof(lt.begin()) it = lt.begin();
while (it != lt.end()) {
msg = *it;
++it;
}
}
end = time(NULL);
cout << "list spend time " << end - start << endl;
return 0;
}
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <afxtempl.h>
int main()
{
std::vector<std::string> linesVector;
std::ifstream file("D:\\使用说明.txt");
if (file.is_open())
{
std::string line;
while (std::getline(file, line))
{
linesVector.push_back(line);
}
file.close();
}
CArray<CString> linesArray;
for (const auto& line : linesVector)
{
linesArray.Add(CString(line.c_str()));
}
// 访问CArray对象中的行内容
for (int i = 0; i < linesArray.GetSize(); i++)
{
CString line = linesArray.GetAt(i);
std::string li_string = (std::string)li_string;
OutputDebugString(line);
}
return 0;
}
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
using namespace std;
#define MAX_L 16 //最大层数
#define prob 0.5 //有i+1级指针的结点占有i级指针的结点的比例
//结点结构
typedef struct node
{
int key;//键值
struct node* next[1];//多层链表结点
} Node;
//跳跃表结构
typedef struct skiplist
{
int level;//最大层数
Node* head;//表头结点
} Skiplist;
//创建结点
Node* create_node(int level, int key)
{
Node* p = (Node*)malloc(sizeof(Node) + level * sizeof(Node*));//分配对应层次的结点
if (!p)
return NULL;
p->key = key;
return p;
}
//创建跳跃表
Skiplist* create_sl()
{
Skiplist* sl = (Skiplist*)malloc(sizeof(Skiplist));
if (!sl)
return NULL;
sl->level = 0;//初始化跳跃表层数为0层
Node* h = create_node(MAX_L - 1, 0);//创建跳跃表头结点
if (!h)
{
free(sl);
return NULL;
}
sl->head = h;
for (int i = 0; i < MAX_L; i++)
h->next[i] = NULL;//初始化数组
return sl;
}
double random()//生成0~1的随机数
{
double q = rand() / (double)RAND_MAX;
return q;
}
static int level_rand()//生成新结点的级数
{
int level = 1;
while (random() <= prob)
level++;
return (level <= MAX_L) ? level : MAX_L;
}
//向跳跃表中插入元素
bool insert(Skiplist* sl, int key)
{
//step1:查找到在每层待插入位置,更新update数组
Node* update[MAX_L];
Node* q = NULL, * p = sl->head;
//找到每一层插入前的一个结点,放在update数组中
for (int i = sl->level - 1; i >= 0; i--)
{
while ((q = p->next[i]) && q->key < key)
p = q;
update[i] = p;
}
if (q && q->key == key)//如果插入的结点已经存在
{
return true;
}
/**************************************/
//step2:随机产生一个层数
int level = level_rand();//随机产生新结点的层数
//如果新生成的结点层数比原跳跃表大
if (level > sl->level)
{
for (int i = sl->level; i < level; i++)
{
update[i] = sl->head;//多出的层数讲跳跃表头结点放入update数组
}
sl->level = level;//更新跳跃表的层数
}
/****************************************/
//step3:从高层至下插入
q = create_node(level, key);//创建新结点
if (!q)
return false;
//根据update数组在每一层中插入新结点
for (int i = level - 1; i >= 0; i--)
{
q->next[i] = update[i]->next[i];
update[i]->next[i] = q;
}
return true;
}
//删除跳跃表中的元素
bool erase(Skiplist* sl, int key)
{
Node* update[MAX_L];
Node* q = NULL, * p = sl->head;
//找到每一层待删除前的一个结点,放在update数组中
for (int i = sl->level - 1; i >= 0; i--)
{
while ((q = p->next[i]) && q->key < key)
p = q;
update[i] = p;
}
//判断q是否为待删除的结点
if (!q || (q && q->key != key))
return false;
//从最高层开始逐层删除结点
for (int i = sl->level - 1; i >= 0; i--)
{
if (update[i]->next[i] == q)
{
update[i]->next[i] = q->next[i];
//如果删除了最高层唯一的结点，则层数减一
if (sl->head->next[i] == NULL)
sl->level--;
}
}
free(q);
return true;
}
//查找跳跃表中元素
Node* search(Skiplist* sl, int key)
{
Node* q = NULL, * p = sl->head;
for (int i = sl->level - 1; i >= 0; i--)
{
while ((q = p->next[i]) && q->key < key)
p = q;
if (q && q->key == key)
return q;
}
return NULL;
}
//从最高层开始逐层打印
void print(Skiplist* sl)
{
Node* q;
for (int i = sl->level - 1; i >= 0; i--)
{
q = sl->head->next[i];
printf("level %d:\n", i + 1);
while (q)
{
printf("key:%d\t", q->key);
q = q->next[i];
}
printf("\n");
}
}
//释放跳跃表
void free_sl(Skiplist* sl)
{
if (!sl)
return;
Node* q = sl->head;
Node* next;
while (q)
{
next = q->next[0];
free(q);
q = next;
}
free(sl);
}
int main()
{
srand((int)time(0));//随机数种子
Skiplist* sl = create_sl();
for (int i = 1; i < 20; i++)
{
insert(sl, i);
}
print(sl);
cout << "******************************" << endl;
for (int i = 11; i < 20; i++)
{
if (!erase(sl, i))
printf("No!\n");
}
print(sl);
free_sl(sl);
return 0;
}
//#include "pch.h"
#include <iostream>
#include<cmath>
using namespace std;
int main()
{
float a = 0;
cout<<atan(3.0 / a);
float c = 1 / a;
cout << c;
int b = 0;
if(a==b)
{
cout << "hello";
}
else
{
cout << "bad";
}
}
/**class TestCallback {
public:
int num = 5;
static int num2;
void call(void(*callback)(int));
static void callBack2(int num);
};
int TestCallback::num2 = 6;//静态变量必须初始化
void callBack1(int num)
{
cout << "------start func1------" << endl;
cout << "func1的num = " << num << endl;
cout << "------end func1------" << endl;
}
void TestCallback::call(void(*callback)(int))
{
cout << "------调用回调------" << endl;
callback(this->num);
cout << "------调用结束" << endl;
cout << endl;
}
void TestCallback::callBack2(int num)
{
cout << "------start func2------" << endl;
cout << "func2的num = " << num << endl;
cout << "func2访问类的静态成员变量num2 = " << TestCallback::num2 << endl;
cout << "------end func2------" << endl;
}
int main()
{
TestCallback t;
t.call(callBack1);
t.call(TestCallback::callBack2);
}*/
#pragma once
#ifndef LINK_STACK_H
#define LINK_STACK_H
namespace xmj{
#define MAX_SIZE 20
/*
******作业思路
******采用双向链表
*****栈底指向头节点，栈顶指向入栈的节点。出栈：栈顶指针利用节点反方向指针折返
*/
typedef int DateType;
typedef struct DateLink {
//DateType* date;
DateType date;
DateLink* front;
DateLink* next;
DateLink();
/*DateLink(const DateLink& other);
const DateLink& operator=(const DateLink& other);
~DateLink();*/
}DLhead;
typedef DateLink* DateLink_ptr;
typedef struct LinkStack {
size_t length;
DateLink_ptr top;
DateLink_ptr base;
LinkStack();
}LS;
bool initLinkStack(LinkStack& linkStack, DLhead& head);
bool pushLinkStack(LinkStack& linkStack, DateLink& dateNode, DLhead& head);
bool popLinkStack(LinkStack& linkStack, DateLink& dateNode);
size_t LinkStackCount(LinkStack& linkStack);
bool deleteLinkStack(LinkStack& linkStack);
}
#endif // !LINK_STACK_H
#include"LinkStack.h"
#include<string.h>
namespace xmj{
LinkStack::LinkStack() {
length = 0;
top = nullptr; base = nullptr;
}
DateLink::DateLink() {
//date = new DateType();
date = 0;
front = nullptr;
next = nullptr;
}
//DateLink::DateLink(const DateLink& other) {
// date = new DateType();
// memcpy(date, other.date, sizeof(DateType));
// next = nullptr;
//}
//const DateLink& DateLink::operator=(const DateLink& other) {
// date = new DateType();
// memcpy(date, other.date, sizeof(DateType));
// next = nullptr; return other;
//}
//DateLink::~DateLink() { delete date; }
bool pushLinkStack(LinkStack& linkStack, DateLink& dateNode, DLhead& head) {
if (linkStack.length == MAX_SIZE)return false;
if (head.next == nullptr&&linkStack.base== linkStack.top) {
head.next = &dateNode; dateNode.front = &head;
linkStack.top = &dateNode; linkStack.length++;
return true;
}
linkStack.top->next = &dateNode; dateNode.front = linkStack.top;
linkStack.top = &dateNode; linkStack.length++;
return true;
}
bool popLinkStack(LinkStack& linkStack, DateLink& dateNode) {
if (linkStack.length == 0)return false;
DateLink* tp = linkStack.top;
dateNode = *tp;
linkStack.top = tp->front;
linkStack.top->next = nullptr; delete tp;
linkStack.length--;
return true;
}
size_t LinkStackCount(LinkStack& linkStack) {
return size_t(linkStack.length);
}
bool deleteLinkStack(LinkStack& linkStack) {
if (linkStack.length==0)return false;
while ((linkStack.length)>0) {
DateLink* tp = linkStack.top;
linkStack.top = tp->front;
linkStack.top->next = nullptr; delete tp;
linkStack.length--;
}
linkStack.base=nullptr; linkStack.top = linkStack.base;
return true;
}
bool initLinkStack(LinkStack& linkStack, DLhead& head) {
if (&linkStack == nullptr || !&head)return false;
linkStack.base = &head;
linkStack.top = linkStack.base;
return true;
}
}
#pragma once
#ifndef SQ_STACK2_H
#define SQ_STACK2_H
#define MAX_SIZE 20
typedef int DateType;
typedef struct SQ_STACK2 {
size_t top;
DateType* base;
SQ_STACK2();
}SQ_S2;
bool initSqStack2(SQ_STACK2& sqStack, size_t maxSize);
bool pushSqStack2(SQ_STACK2& sqStack, DateType date);
bool popSqStack2(SQ_STACK2& sqStack, DateType& popDate);
size_t sqStackCount2(SQ_STACK2& sqStack);
bool deleteSqStack2(SQ_STACK2& sqStack);
#endif // !SQ_STACK2_H
#include"SqStack2.h"
SQ_STACK2::SQ_STACK2() {
top = 0; base = nullptr;
}
bool initSqStack2(SQ_STACK2& sqStack, size_t maxSize) {
if (&sqStack == nullptr || maxSize < 1)return false;
sqStack.base = new DateType[maxSize]();
return true;
}
bool pushSqStack2(SQ_STACK2& sqStack, DateType date) {
if (!&sqStack || sqStack.top == MAX_SIZE || !sqStack.base)return false;
*(sqStack.base+ sqStack.top) = date; sqStack.top++;
return true;
}
bool popSqStack2(SQ_STACK2& sqStack, DateType& popDate) {
if (!&sqStack || sqStack.top == 0 || !sqStack.base)return false;
popDate = *(sqStack.base + --sqStack.top);
return true;
}
size_t sqStackCount2(SQ_STACK2& sqStack) {
return size_t(sqStack.top);
}
bool deleteSqStack2(SQ_STACK2& sqStack) {
if (!&sqStack)return false;
sqStack.top = 0;
delete sqStack.base;
return true;
}
海前 王 - Aug 27 - 
