猫眼撸代码题汇总

最新推荐文章于 2024-05-15 07:14:42 发布
吴珝君
最新推荐文章于 2024-05-15 07:14:42 发布
阅读量296
点赞数
分类专栏：实习笔试 C++
本文链接：https://blog.csdn.net/weixin_39804483/article/details/90210187
版权
C++ 同时被 2 个专栏收录
9 篇文章 0 订阅
订阅专栏
实习笔试
8 篇文章 0 订阅
订阅专栏
1、排序
2、topk
3、栈实现队队实现栈
4、查找子串的出现次数
5、数组实现栈／队列
6、求最大连续子序列
7、查找数组中是否存在当前的元素
//
//  main.cpp
//  cateye
//
//  Created by 吴珝君 on 2019/5/10.
//  Copyright © 2019年 闲着也是贤者. All rights reserved.
//

#include <iostream>
#include <vector>
#include <string>
using namespace std;
//从小到大排序
void quicksort(vector<int> &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[high]) {
                high--;
            }
            if (low < high) {
                v[low] = v[high];
                low++;
            }
            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<int> &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 <algorithm>
void merge1(vector<int> &v, int low, int mid, int high)
{
    int i = low, j = mid+1;
    vector<int> 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] <<endl;
    }
    
    
}
void mergesort(vector<int> &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<int> &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<int> &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<int> &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<int> &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<int> & 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<int> & 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<<begin<<"  "<<count<<endl;
    begin=begin+P.length();
}
}//就是查找字符串
//如何用栈实现队列
/*
 栈的特点是先进后出，队的特点是先进后出，那么我们使用两个栈来模拟队的特点，
 一个是存入栈，一个是辅助栈。要注意的问题是只有当整个辅助栈为空的时候，我们
 才将主栈中的元素存入辅助栈
 */
#include <stack>
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()<<endl;
            help.pop();
        }

    }
     int front()
    {
        
        if (help.empty())
        {
            
            if ( !main.empty())
            {
                
                while (!main.empty())
                {
                    help.push(main.top());
                    main.pop();
                }
            }
        }
        
        if (help.empty()) {
            cout <<" queue empty"<<endl;
            return -1;
        }
        else
            return help.top();
    }
    bool empty()
    {
        if (main.size() + help.size() ==0) {
            return true;
        }
        else
            return false;
        
    }
    int size()
    {
        if (empty()) {
            return 0;
        }
        else
            return main.size() + help.size();
        
        
    }
private:
    stack<int> main;
    stack<int> help;
};



//常见的端口号 。。。。。。
#define MAX 9
class arrayqueue
{
public:
    arrayqueue()
    {
        head = -1;
        tail = -1;
    }
    void push(int t)
    {
        //如何判断队满河队空
        if ((tail +1)%MAX == head) {
            cout <<"队满了，存不下"<<endl;
        }
        else
        {
            tail = (tail +1 ) % MAX;
            arr[tail] = t;
        }
    }
    void  pop( )
    {
        if (head == tail) {
            cout <<"队列为空呀" <<endl;
        }
        else
        {
            
            head = (head +1 )% MAX;
        }
    }
    int front()
    {
        if (head == tail) {
            cout<<"队列是空的"<<endl;
            return -1;
        }
        else
            return arr[(head +1)%MAX];
        
    }
    int size()
    {
        if (head == tail) {
            return 0;
        }
        else
        
            return (tail - head +MAX )%MAX;
        
        
        
    }
    
    
private:
    int arr[MAX];
    int  head;
    int  tail;
};
//如何用数组实现栈

class mystack
{
public:
    mystack()
    {
      //  button = -1;
        top = -1;
    }
    void push(int t)
    {
        if (top + 1 == MAX) {
            cout <<"stack is full" <<endl;
        }
        else
            arr[++top] = t;
        
    }
    bool empty()
    {
        if (top == -1) {
            return true;
        }
        else
            return false;
    }
    int size()
    {
        return top +1;
        
    }
    void pop()
    {
        if (empty()) {
            cout <<"stack empty" <<endl;
        }
        else
            top--;
    }
    int topp()
    {
        if (empty()) {
            cout <<"stack empty" <<endl;
            return -1;
        }
        else
        return arr[top];
    }
private:
    int arr[MAX];
    int top ;
    //int button;
};
/*
 统计一下输入的字符串中，有多少数字，字母和空格？
 */
 vector<int> getCount(string s)
{
    vector<int> 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 <queue>
//如何用队列来实现栈
class doublestack
{
public:
    void push(int t)
    {
        if (main.empty()) {
            help.push(t);
           // cout << t<<endl;
        }
        else
        { main.push(t);
       //   cout << t<<endl;
        }
        
    }
    void pop()
    {
        if (main.empty() && help.empty()) {
            cout <<"stack empty" <<endl;
        }
        else
        {
            if (main.empty()) {
                int len = help.size();
                for (int i =0; i < len -1; i++)
                {
                    main.push(help.front());
                    help.pop();
                }
                help.pop();
            }
            else
            {
                int len = main.size();
                for (int i =0; i < len-1; i++)
                {
                    help.push(main.front());
                    main.pop();
                }
                main.pop();
            }
        }
    }
    int  top()
    {
        if (help.empty() && main.empty()) {
            cout << "stack empty" <<endl;
            return -1;
        }
        else {
                if (main.empty()) {
                    int len = help.size();
                    for (int i =0; i < len -1; i++) {
                        main.push(help.front());
                        help.pop();
                    }
                    int t = help.front();
                    help.pop();
                    main.push(t);
                    return t;
                }
                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);
                    return t;
                }
            
        }
        
        
    }
    
    int size()
    {
        
        return main.size() + help.size();
        
        
    }
    
private:
    queue<int> main;
    queue<int> 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<int> main;
    queue<int> 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<int> 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<binTree *> q;
    q.push(b);
    while (!q.empty()) {
        binTree *t = q.front();
        cout << t->value<<endl;
        q.pop();
        if (t->left != NULL) {
            q.push(t->left);
        }
        if (t->right!=NULL) {
            q.push(t->right);
        }
    }
    
}
//按照之字形打印二叉树
vector<int>  travelbyzigzag(binTree *b)
{
    vector<int> v;
    stack<binTree*> s1;
    stack<binTree*> 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 <functional>
vector<int> getTopK(vector<int> v, int k)
{
    vector<int> vt;
    if (k >=v.size()) {
        
        vt = v;
        return vt;
    }
    
   //priority_queue<int,vector<int>,less<int>> q;
     priority_queue<int,vector<int>,greater<int>> 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<int> getTopKmin(vector<int> v, int k)
{
    vector<int> vt;
    if (k >=v.size()) {
        
        vt = v;
        return vt;
}
    
   priority_queue<int,vector<int>,less<int>> q;//默认建立小顶堆
   // priority_queue<int> 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 <<q.top()<<endl;
        //q.pop();
    }
    int len = q.size();
    for (int i = 0; i < len ; i++) {
        vt.push_back(q.top());
        q.pop();
    }
    return vt;
}
//直接选择排序
void insertsort(vector<int> &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<int> 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<vector<int> > 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 <map>
int main(int argc, const char * argv[]) {
    return 0;
}