五种经典数据结构算法解析-优快云博客

文章目录

1.数组：二维数组中的查找

题目描述：
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
解法思路：
法一：把每一行看成有序递增的数组，利用二分查找，通过遍历每一行得到答案，时间复杂度是nlogn；

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if (array.empty())
            return false;
        for (int i = 0; i < array.size(); i++) {
            int low = 0;
            int high = array[i].size() - 1;
            while(low <= high) {
                int mid = (low + high)/2;
                if (target < array[i][mid])
                    high = mid - 1;
                else if (target > array[i][mid])
                    low = mid + 1;
                else 
                    return true;
            }
        }
        return false;
    }
};

法二：利用二维数组由上到下，由左到右递增的规律，那么选取右上角或者左下角的元素a[row][col]与target进行比较：
此处初始选取右上角元素：
当target小于元素a[row][col]时，那么target必定在元素a所在列的左边,即col–；
当target大于元素a[row][col]时，那么target必定在元素a所在行的下边,即row++；

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        if (array.empty())
            return false;
        int row = 0;
        int col = array[0].size() - 1;
        while (row <= array.size() - 1 && col >= 0) {
            if (target < array[row][col])
                col--;
            else if(target > array[row][col])
                row++;
            else
                return true;
        }
        return false;
    }
};

2.字符串：替换空格

题目描述：
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
解法思路：
在当前字符串替换，怎么替换才更有效率（不考虑java里现有的replace方法）？
（1）从前往后替换，后面的字符要不断往后移动，要多次移动，所以效率低下；
（2）从后往前，先计算需要多少空间，然后从后往前移动，则每个字符只为移动一次，这样效率更高一点；

class Solution {
public:
	void replaceSpace(char *str,int length) {
        int num_blank = 0;
        for (int i = 0; i < length; i++) {
            if (*(str+i) == ' ')
                num_blank++;
        }
        int new_length = length + num_blank*2;
        int i = length - 1;
        int j = new_length - 1;
        for (; i >= 0; i--) {
            if (*(str+i) == ' ') {
                *(str+j--) = '0';
                *(str+j--) = '2';
                *(str+j--) = '%';
            }
            else
                *(str+j--) = *(str+i);
        }
	}
};

3.链表：从尾到头打印链表

题目描述：
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。
解法思路：
利用vector操作可以直接实现；

/**
*  struct ListNode {
*        int val;
*        struct ListNode *next;
*        ListNode(int x) :
*              val(x), next(NULL) {
*        }
*  };
*/
class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> arr;
        if (head != NULL) {
            arr.insert(arr.begin(), head->val);
            while (head->next != NULL) {
                arr.insert(arr.begin(), head->next->val);
                head = head->next;
            }
        }
        return arr;
    }
};

class Solution {
public:
    vector<int> printListFromTailToHead(ListNode* head) {
        vector<int> array;
        ListNode* p = head;
        while (p) {
            array.push_back(p->val);
            if (!(p->next)) {
                break;
            }
            p = p->next;
        }
        reverse(array.begin(),array.end());
        return array;
    }
};

4.树：重建二叉树

题目描述：
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解法思路：
前序遍历序列首结点即为根结点，因此在中序遍历中找到此根结点，即可将左子树和右子树分开，在左子树和右子树中，同理可继续进行此操作，递归完成建树过程。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if (pre.empty() || vin.empty())
            return NULL;
        vector<int> pre_left, pre_right, vin_left, vin_right;
        int val = pre[0];
        TreeNode *root = new TreeNode(val);
        int vin_size = vin.size();
        int i_vin;            //记录根结点在中序遍历序列中的位置
        for (i_vin = 0; i_vin < vin_size; i_vin++) {
            if (vin[i_vin] == val)
                break;
        }
        for (int i = 0; i < i_vin; i++) {
            pre_left.push_back(pre[i+1]);
            vin_left.push_back(vin[i]);
        }
        for (int i = i_vin+1; i < vin_size; i++) {
            pre_right.push_back(pre[i]);
            vin_right.push_back(vin[i]);
        }
        root->left = reConstructBinaryTree(pre_left, vin_left);
        root->right = reConstructBinaryTree(pre_right, vin_right);
        return root;

    }
};

5.栈和队列：用两个栈实现队列

题目描述：
用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。
解法思路：
入栈：将stack2中数据都倒入stack1，再在stack1中入栈；
出栈：将stack1中数据都倒入stack2，再在stack2中出栈。

class Solution {
public:
    void push(int node) {
        while (!stack2.empty()) {
            int val = stack2.top();
            stack1.push(val);
            stack2.pop();
        }
        stack1.push(node);
    }
    int pop() {
        while(!stack1.empty()) {
            int val = stack1.top();
            stack2.push(val);
            stack1.pop();
        }
        int val = stack2.top();
        stack2.pop();
        return val;
    }
private:
    stack<int> stack1;
    stack<int> stack2;
};