1、排序
2、topk
3、栈实现队 队实现栈
4、查找子串的出现次数
5、数组实现栈 /队列
6、求最大连续子序列
7、查找数组中是否存在当前的元素
//
// main.cpp
// cateye
//
// Created by 吴珝君 on 2019/5/10.
// Copyright © 2019年 闲着也是贤者. All rights reserved.
//
#include
#include
#include
using namespace std;
//从小到大排序
void quicksort(vector &v, int i , int j)
{
int low = i;
int high = j;
int temp = v[low];
if (low < high) {
//将第一个元素作为枢纽 从后往前比较
while(low < high)
{
while (low < high && temp =v[low]) {
low++;
}
if (low < high) {
v[high] = v[low];
high--;
}
}
v[low] = temp;
quicksort(v, i, low-1);
quicksort(v, low +1, j );
}
}
void qquicksort(vector &v, int low, int high)
{
int i = low;
int j = high;
if (i < j) {
int temp = v[i];
while (i < j) {
//如果当前值比temp大,那么我就不动 好不好
while (i < j && temp <= v[j]) {
j--;
}
if (i < j) {
v[i] = v[j];
i++;
}
while (i < j && temp > v[i]) {
i++;
}
if (i < j) {
v[j] = v[i];
j--;
}
}
v[i] = temp;
qquicksort(v, low, i -1 );
qquicksort(v, i+1,high );
}
}
//不稳定排序 时间复杂度最好的情况下是O(nlogn) 最坏的情况下是O(n2)空间复杂度是O(logn)
//二路归并排序
#include
void merge1(vector &v, int low, int mid, int high)
{
int i = low, j = mid+1;
vector t;
while (i <=mid && j <= high )
{
if (v[i] < v[j]) {
t.push_back(v[i]);
i++;
}else
{
t.push_back(v[j]);
j++;
}
}
while (i <= mid)
{
t.push_back(v[i++]);
}
while (j <= high)
t.push_back(v[j++]);
for (int i = 0; i < t.size(); i++)
{
v[low++] = t[i];
// cout << v[low] < &v, int low , int high)
{
if (low < high) {
int mid = (low +high)/2;
mergesort(v, low, mid);
mergesort(v, mid+1, high);
merge1(v, low, mid, high);
}
}
//除了归并排序 还有堆排序
/*
堆是一种数据结构,我们可以将其看作完全二叉树,这颗二叉树满足,任何一个非叶子结点的值的大小
不小于其左右孩子的值的大小 以下我们使用传统的方法建立完全二叉树
*/
//这里我们对编号的操作是从0开始的 我们的目标是为了建立一个大顶堆
/*
*/
void adjust(vector &v, int low , int high)
{
int i = low;
int j = 2*i +1;//left
int temp = v[low];
while (j <=high) {
if (j+1 <=high && v[j] < v[j+1]) {
j++;
}
if (v[j] > temp) {
v[i] = v[j];
i = j;//得到上次调整的结点
j = 2*i + 1;//继续像下找
}
else
break;
}
v[i] = temp;
}
void heapsort(vector &v)
{
int len = v.size() -1;
for (int i = (len -1)/2; i>=0; i--) {
adjust(v, i, len);
}
//拿出最大的元素
for (int i = len; i >0 ; i--) {
swap(v[0], v[i]);
adjust(v, 0, i-1);//i结点已经有顺序了。
}
}
void myadjustheap(vector &v, int low, int high)
{
int i = low;
int j= 2*i +1;//左边孩子
int temp = v[i];
while (j <= high) {
if (j+1 <= high && v[j] < v[j+1]) {
j++;
}
if (v[j] > temp) {
v[i] = v[j];
i = j;
j = 2*i +1;
}
else
break;
}//一定能进入循环
v[i] = temp;
}
//堆排序的实现呀 小伙子
void myheapsort(vector &v)
{
//建立堆的过程
int len = v.size() -1;//从下标为0开始计数
//建立堆
for (int i =(len -1 )/2; i >=0; i--) {
myadjustheap(v, i, len);
}
//调整堆
for (int i = len ; i>0; i--) {
swap(v[i], v[0]);
myadjustheap(v, 0,i -1 );
}
}
void bubblesort(vector & v)
{
int len = v.size();
for (int i = 0; i < len; i++)
{
int index =0;
for (int j = 1; j < len -i; j++)
{
if (v[j -1] > v[j])
{
swap(v[j-1], v[j]);
index = 1;
}
}
if (index == 0) {
break;
}
}
}
//选择排序 么么哒
void selectSort(vector & v)
{
int len = v.size();
for (int i = 0; i < len ; i++)
{
int temp = v[i];
int index =i;
for (int j = i+1; j < len; j++) {
if ( v[j] < temp) {
temp = v[j];
index = j;
}
}
swap(v[i], v[index]);
}
}
//排序方式:冒泡 选择、快排 归并、堆排序
//查找字符串A 在字符串B中的出现次数:简单的字符串分割
int getCount(string father, string son)
{
string::size_type pos1 = 0, pos2 =0;
int count = 0;
pos2 = father.find(son);
while (pos2 != string::npos) {
count++;
pos1 = pos2 + son.size();
pos2 = father.find(son, pos1);
}
if (pos1 != father.length()) {
// count++;
// cout << "OK";
}
return count;
}
//问:::::如何写测试用例??????
void find(string T, string P)
{
int count=0;
int begin=0;
while((begin=T.find(P,begin))!=string::npos)
{
count++;
cout<
class myqueue
{
public:
void push(int t)
{
main.push(t);
}
void pop()
{
if (help.empty())
{
if ( !main.empty())
{
while (!main.empty())
{
help.push(main.top());
main.pop();
}
}
}
else
{
//cout << help.top()< main;
stack help;
};
//常见的端口号 。。。。。。
#define MAX 9
class arrayqueue
{
public:
arrayqueue()
{
head = -1;
tail = -1;
}
void push(int t)
{
//如何判断队满河队空
if ((tail +1)%MAX == head) {
cout <<"队满了,存不下"< getCount(string s)
{
vector v;
int num = 0;
int zimu =0;
int space = 0;
for (int i = 0; i < s.length(); i++) {
if ((s[i]>='a'&& s[i]<='z')||(s[i]>='A'&& s[i]<='Z')) {
zimu++;
}
else if(s[i] ==' ')
space++;
else if((s[i]>='0'&& s[i]<='9'))
num++;
}
v.push_back(num);
v.push_back(zimu);
v.push_back(space);
return v;
}
#include
//如何用队列来实现栈
class doublestack
{
public:
void push(int t)
{
if (main.empty()) {
help.push(t);
// cout << t< main;
queue help;
};
class doublestacks
{
public:
void push(int t)
{
main.push(t);
}
int top()
{
if (main.empty()) {
cout << "stack empty" << endl;
return - 1;
}
else
{
int len = main.size();
for (int i = 0; i < len -1; i++) {
help.push(main.front());
main.pop();
}
int t = main.front();
main.pop();
help.push(t);
swap(main, help);
return t;
}
return -1;
}
void pop()
{
if (main.empty()) {
cout << "stack empty" << endl;
return ;
}
else
{
int len = main.size();
for (int i = 0; i < len -1; i++) {
help.push(main.front());
main.pop();
}
main.pop();
swap(main, help);
}
return ;
}
int size()
{
return main.size();
}
private:
queue main;
queue help;
};
//如何不用乘法实现乘法
long long getValue(long long a, long long b)
{
long long ia = abs(a);
long long ib = abs(b);
long long sum = 0 ;
for (long long i = 0; i < ia; i++) {
sum += ib;
}
if (a*b <0) {
return -1 *sum;
}
else
return sum;
}
//求数组的最大连续子串和
int getmax(vector v)
{
if (v.empty()) {
return 0;
}
int max = v[0];
int t = v[0];
for (int i =1; i < v.size(); i++)
{
//如果加上当前值的话,导致当前值变大,那么说明这个值对结果有贡献,这个是个积极份子
if (v[i] + t >= t)
{
t = v[i] +t;
if (max < t) {
max = t;
}//更新比较大的值
}
else
{
t = 0;
}
}
return max;
}
//层次便利二叉树
typedef struct _bittree
{
_bittree(int value)
{
left = NULL;
right =NULL;
this->value = value;
}
struct _bittree *left;
struct _bittree * right;
int value;
} binTree;
//层次遍历二叉树
void travelbylevel(binTree *b)
{
if (b == NULL) {
return;
}
queue q;
q.push(b);
while (!q.empty()) {
binTree *t = q.front();
cout << t->value<left != NULL) {
q.push(t->left);
}
if (t->right!=NULL) {
q.push(t->right);
}
}
}
//按照之字形打印二叉树
vector travelbyzigzag(binTree *b)
{
vector v;
stack s1;
stack s2;
if (b == NULL)
{
return v;
}
s1.push(b);
while (!s1.empty() || !s2.empty() )
{
if(!s1.empty())
{//从右往左进
while (!s1.empty()) {
binTree *t = s1.top();
v.push_back(t->value);
s1.pop();
if (t->left !=NULL)
{
s2.push(t->left);
}
if (t->right != NULL)
{
s2.push(t->right);
}
}
}
else if(!s2.empty())
{
//从右往左进
while (!s2.empty()) {
binTree *t = s2.top();
v.push_back(t->value);
s2.pop();
if (t->right !=NULL)
{
s1.push(t->right);
}
if (t->left != NULL)
{
s1.push(t->left);
}
}
}
}
return v;
}
typedef struct _head
{
_head(int v)
{
this->val = v;
next =NULL;
}
int val;
struct _head *next;
} list;
list* findCommon(list * s1, list *s2)
{
if (s1 == NULL ||s2 == NULL) {
return NULL;
}
list *l1,*l2;
l1 = s1;
l2 = s2;
int len1 = 0,len2 =0;
while (l1 !=NULL) {
len1++;
l1 = l1->next;
}
while (l2 != NULL) {
len2++;
l2 = l2->next;
}
int n =0;
if (len1 >=len2) {
n = len1 - len2;
l1 = s1;
l2 = s2;
}
else
{
n = len2 - len1;
l1= s2;
l2 = s1;
}
while (n--) {
l1 = l1->next;
}
while (l1!=NULL)
{
if (l1 == l2)
{
return l1;
}
else
{
l1 = l1->next;
l2 =l2->next;
}
}
return NULL;
}
#include
vector getTopK(vector v, int k)
{
vector vt;
if (k >=v.size()) {
vt = v;
return vt;
}
//priority_queue,less> q;
priority_queue,greater> q;//默认建立大顶堆
for (int i = 0; i < k; i++) {
q.push(v[i]);
}
for (int i = k; i < v.size(); i++) {
if (q.top() > v[i]) {
q.pop();
q.push(v[i]);
}
}
int len = q.size();
for (int i = 0; i < len ; i++) {
vt.push_back(q.top());
q.pop();
}
return vt;
}
vector getTopKmin(vector v, int k)
{
vector vt;
if (k >=v.size()) {
vt = v;
return vt;
}
priority_queue,less> q;//默认建立小顶堆
// priority_queue q;//默认建立小顶堆
for (int i = 0; i < k; i++) {
q.push(v[i]);
}
for (int i = k; i < v.size(); i++) {
if (q.top() > v[i]) {
q.pop();
q.push(v[i]);
}
//cout < &v)
{
for (int i = 1; i < v.size(); i++) {
int temp = v[i];
if(v[i]>v[i-1])
for (int j =i; j>0; j-- ) {
if (temp>v[j-1 ]) {
v[j] = v[j-1];
}
else
{
v[j] = temp;//j是空余位置
break;
}
}
}
}
int binserch(vector v,int key)
{
int low = 0;
int high = v.size() -1;
int mid = 0;
while (low <=high) {
mid = (low + high)/2;
if (key == v[mid]) {
return mid;
}
else if(key< v[mid])
{
low = mid +1;
}
else
{
high = mid -1;
}
}
return -1;
}
class Solution {
public:
bool Find(int target, vector > array) {
//从第一行的最后一个元素开始找,比当前元素大,则往下边找,比当前元素小,则往右边找,否则相等
int rlen = array.size() ;//行数
int clen = array[0].size();//列数
int i = 0;//行数下标
int j = clen -1;//列数下标
while (i < rlen && j >=0) {
if (array[i][j] == target) {
return true;
}
else if(array[i][j] > target)
j--;
else
i++;
}
return false;
}
//
};
#include