leetcode刷题：每日一题-724. 寻找数组的中心索引 、剑指 Offer 09. 用两个栈实现队列和队列实现栈 and 牛客网刷题：找到字符串的最长无重复字符子串

思路：先求整个数组的和，然后从头求和，当遍历到某数时，此时该和=（总和-该值）/2时，说明该数就是中心索引。

class Solution {
public:
    int pivotIndex(vector<int>& nums) {
        if (nums.empty())
            return -1;

        int n = nums.size();
        int sum=0;
        int sum_new=0;
        int index;
        for(int i=0;i<n;i++)
            sum+=nums[i];
        for(int i=0;i<n;i++)
        {
            if (sum_new == (sum-nums[i])/2.00)
                return i;
            sum_new += nums[i];
        }
        return -1;
    }
};

思路：自习分析队列和栈的关系即可。

class CQueue {
public:
    CQueue() {
        
    }
    stack<int> s1;
    stack<int> s2;
    void appendTail(int value) {
        s1.push(value);
    }
    
    int deleteHead() {
        int result;
        if (s2.empty()){
            while (!s1.empty())
            {
                result = s1.top();
                s1.pop();
                s2.push(result);
            }
        }
        if (!s2.empty())
        {
            result = s2.top();
            s2.pop();
            return result;
        }
        else
            return -1;
    }
};

class MyStack {
public:
    /** Initialize your data structure here. */
    MyStack() {

    }
    queue<int> q1;
    queue<int> q2;
    /** Push element x onto stack. */
    void push(int x) {
        q1.push(x);
    }
    
    /** Removes the element on top of the stack and returns that element. */
    int pop() {
         int temp;
        while(q1.size()>1)
        {
            temp = q1.front();
            q1.pop();
            q2.push(temp);
        }
        if (!q1.empty())
        {
            temp = q1.front();
            q1.pop();
            
        }
        else
            temp = -1;
        
        while(!q2.empty())
        {
            int temp = q2.front();
            q2.pop();
            q1.push(temp);
        }
        return temp;
    }
    
    /** Get the top element. */
    int top() {
        int temp;
        while(q1.size()>1)
        {
            temp = q1.front();
            q1.pop();
            q2.push(temp);
        }
        if (!q1.empty())
        {
            temp = q1.front();
            return temp;
        }
        else
            return -1;
    }
    
    /** Returns whether the stack is empty. */
    bool empty() {
        if (q1.empty())
            return true;
        else
            return false;
    }
};

思路：从头开始建立不重复数字字符串，建立原则：只要该数不存在该字符数组中，则加入不重复字符串，并实时记录不重复字符串长度，如果存在该字符串中，则将从头到与该数重复的数位置的字符串前部分删除，然后继续遍历。（ps:检查字符是否存在时可利用hash方法）

class Solution {
public:
    /**
     * 
     * @param arr int整型vector the array
     * @return int整型
     */
    int maxLength(vector<int>& arr) {
        // write code here 
        if (arr.empty())
            return 0;
        int max_length=0;
        vector<int> no_chongfu;
        //利用hash方法
        //map<int,int> hashtable;
        int n = arr.size();
        //遍历所有数 找出有重复数组的位置 
        for(int i=0;i<n;i++)
        {
            int pos =findchongfu(no_chongfu,arr[i]);
            //int pos =findchongfu(hashtable,arr[i]);
            if ( pos == -1)   //如果没找到
                no_chongfu.push_back(arr[i]);
                //hashtable.insert(pair<int,int> (arr[i],i));
            else                                    //如果找到了
            {
//                 map<int,int>::iterator iter = hashtable.find(arr[i]);
//                 hashtable.erase(hashtable.begin(), iter);
//                 hashtable.erase(iter);
//                 hashtable.insert(pair<int,int> (arr[i],i));
                no_chongfu.erase(no_chongfu.begin(),no_chongfu.begin()+pos+1);
                no_chongfu.push_back(arr[i]);
            }
            if (max_length<no_chongfu.size())
                max_length = no_chongfu.size();
//             if (max_length<hashtable.size())
//                 max_length = hashtable.size();
        }
        return max_length;
    }
    int findchongfu(vector<int> no_chongfu,int value)
    {
        for(int i=0;i<no_chongfu.size();i++)
        {
            if ( no_chongfu[i] == value )
                return i;
        }
        return -1;
    }
//     int findchongfu(map<int,int> hashtable,int value)
//     {
//         map<int,int>::iterator iter;
//         iter = hashtable.find(value);
//         if (iter!=hashtable.end())
//                 return iter->second;
//         return -1;
//     }
    
};

PS：牛客网编译器暂不支持unordered_map和hash_map,然而map会自动根据插入值的key值由小到大进行排序，所以在删除元素时，会打乱想要删除的数据的顺序。