剑指offer 重建二叉树 旋转数组的最小数字 链表中倒数第k个结点 反转链表

时间限制：1秒  空间限制：32768K  热度指数：297240

 算法知识视频讲解

题目描述

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{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> in) {
        vector<int>pre_left,pre_right,in_left,in_right;
        if(in.size()==0) return NULL;
        int pre_size = pre.size();
        int in_size = in.size();
        int root_val = pre[0];
        TreeNode* node = new TreeNode(root_val);
        int mark=0;
        for(;mark<in_size;mark++)
        {
            if(in[mark]==root_val)
                break;
        }
        for(int i=0;i<in_size;i++)
        {
            if(i<mark){
                in_left.push_back(in[i]);
                pre_left.push_back(pre[i+1]);
            }
            else if(i>mark){
                in_right.push_back(in[i]);
                pre_right.push_back(pre[i]);
            }
        }
        node->left=reConstructBinaryTree(pre_left,in_left);
        node->right=reConstructBinaryTree(pre_right,in_right);
        return node;
    }
};

时间限制：3秒  空间限制：32768K  热度指数：269636

本题知识点：  查找

 算法知识视频讲解

题目描述

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非递减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        sort(rotateArray.begin(),rotateArray.end());
        return rotateArray[0];
    }
};

/*念润大神代码 考虑了重复数字的情况*/
class Solution {
public:
    int minNumberInRotateArray(vector<int> rotateArray) {
        int size = rotateArray.size();
        if(size == 0){
            return 0;
        }//if
        int left = 0,right = size - 1;
        int mid = 0;
        // rotateArray[left] >= rotateArray[right] 确保旋转
        while(rotateArray[left] >= rotateArray[right]){
            // 分界点
            if(right - left == 1){
                mid = right;
                break;
            }//if
            mid = left + (right - left) / 2;
            // rotateArray[left] rotateArray[right] rotateArray[mid]三者相等
            // 无法确定中间元素是属于前面还是后面的递增子数组
            // 只能顺序查找
            if(rotateArray[left] == rotateArray[right] && rotateArray[left] == rotateArray[mid]){
                return MinOrder(rotateArray,left,right);
            }//if
            // 中间元素位于前面的递增子数组
            // 此时最小元素位于中间元素的后面
            if(rotateArray[mid] >= rotateArray[left]){
                left = mid;
            }//if
            // 中间元素位于后面的递增子数组
            // 此时最小元素位于中间元素的前面
            else{
                right = mid;
            }//else
        }//while
        return rotateArray[mid];
    }
private:
    // 顺序寻找最小值
    int MinOrder(vector<int> &num,int left,int right){
        int result = num[left];
        for(int i = left + 1;i < right;++i){
            if(num[i] < result){
                result = num[i];
            }//if
        }//for
        return result;
    }
};

时间限制：1秒  空间限制：32768K  热度指数：314520

本题知识点：  链表

 算法知识视频讲解

题目描述

输入一个链表，输出该链表中倒数第k个结点。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        ListNode* p=pListHead;
        for(int i=0;i<k;i++)
        {
            if(!p) return NULL;
            else p=p->next;
        }
        while(p)
        {
            p=p->next;
            pListHead=pListHead->next;
        }
        return pListHead;
    }
};

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        ListNode* p=pListHead;
        stack<ListNode *>s;
        while(p)
        {
            s.push(p);
            p=p->next;
        }
        int cnt=0;
        ListNode* node;
        while(!s.empty())
        {
            node=s.top();s.pop();
            cnt++;
            if(cnt==k)
                break;
        }
        if(cnt!=k) return NULL;
        return node;
    }
};

时间限制：1秒  空间限制：32768K  热度指数：224113

本题知识点：  链表

 算法知识视频讲解

题目描述

输入一个链表，反转链表后，输出链表的所有元素。

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        stack<ListNode* >s;
        ListNode* p=pHead;
        if(pHead==NULL||pHead->next==NULL) return p;
        while(p->next)
        {
            s.push(p);
            p=p->next;
        }
        ListNode* head=p;
        while(!s.empty())
        {
            p->next=s.top();s.pop();
            p=p->next;
        }
        p->next=NULL;
        return head;
    }
};