剑指offer刷题笔记(3)

来源：互联网发布：警察算法律工作经验编辑：程序博客网时间：2024/05/19 11:50

把二叉树打印成多行知识点：二叉树迭代遍历其实就是把visit函数改变一下就好了，把visit函数放在后面比前面要好

class Solution {
public:
        vector<vector<int> > Print(TreeNode* root) {
        vector<vector<int> > result;
        if (root==NULL)
            return result;
        std::deque<TreeNode*> dequeTreeNode;
        dequeTreeNode.push_back(root);
        int current = 1;
        int next = 0;
            vector<int>member;
        while(!dequeTreeNode.empty())
        {
            TreeNode* pNode = dequeTreeNode.front();
            dequeTreeNode.pop_front();


            if (pNode->left != NULL)
               {
                    dequeTreeNode.push_back(pNode->left);
                    next++;
                }
            if (pNode->right != NULL)
                {
                    dequeTreeNode.push_back(pNode->right);
                    next++;
                }


            {

            member.push_back(pNode->val);
            current--;
           if (current == 0)
            {             
                result.push_back(member);
                member.clear();
                current = next;
                next = 0;
            }

            }
        }

        return result;
        }

};

按之字形顺序打印二叉树知识点：二叉树的迭代遍历多加一个层数的全局变量就好了

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    vector<vector<int> > Print(TreeNode* root) {
                vector<vector<int> > result;
        if (root==NULL)
            return result;
        std::deque<TreeNode*> dequeTreeNode;
        dequeTreeNode.push_back(root);
        int current = 1;
        int next = 0;
        int floor = 0;
            vector<int>member;
        while(!dequeTreeNode.empty())
        {
            TreeNode* pNode = dequeTreeNode.front();
            dequeTreeNode.pop_front();


            if (pNode->left != NULL)
               {
                    dequeTreeNode.push_back(pNode->left);
                    next++;
                }
            if (pNode->right != NULL)
                {
                    dequeTreeNode.push_back(pNode->right);
                    next++;
                }


            {

            member.push_back(pNode->val);
            current--;
           if (current == 0)
            {   
                floor++;
                if ( (floor&0x01) == 0)
                    std::reverse(member.begin(), member.end());
                result.push_back(member);       
                member.clear();
                current = next;
                next = 0;
            }

            }
        }

        return result;

    }

};

旋转数字中的最小数字知识点：二分查找在如何跳出循环里面困了好久，就是l=mid, r = mid. l = mid+ 1为什么不行了呢

class Solution {

public:

int minNumberInRotateArray(vector<int> rotateArray) {

if (rotateArray.size() == 0)

return 0;

if (rotateArray.size()== 1)

return rotateArray[0];

int l = 0;

int r = rotateArray.size() -1;

while (l<=r)

{

int mid = (l+r)/2;

if (rotateArray[mid] == rotateArray[l])

{

l++;

if ( r -l <=1)

break;

}

if (rotateArray[mid] == rotateArray[r])

{

r--;

if ( r -l <=1)

break;

}

if (rotateArray[mid] > rotateArray[l])

l = mid ;

else if (rotateArray[mid] < rotateArray[l])

r = mid ;

}

return rotateArray[l]<rotateArray[r]?rotateArray[l]:rotateArray[r] ;

}

};

简介版也是迷惑于为什么不能low = mid + 1

class Solution {
public:
    int minNumberInRotateArray(vector<int> array) {

                int low = 0 ; int high = array.size() - 1;   
        while(low < high){
            int mid = low + (high - low) / 2;       
            if(array[mid] > array[low]){
                low = mid ;
            }else if(array[mid] == array[low]){
                low = low + 1;
            }else{
                high = mid;
            }   
        }
        return array[low];
    }

};

把数组排成最小的数

class Solution {
public:
    static bool compare( const string &st1,const string &st2){
        string s1 = st1+st2;
        string s2 = st2+st1;
        return s1<s2;
    }
    string PrintMinNumber(vector<int> numbers) {
         string result;
        if(numbers.size()<=0){
            return result;
        }
        vector<string> strNum;
        for(int i=0;i<numbers.size();i++ ){
           stringstream ss;
            ss<<numbers[i];
            string s = ss.str();
            strNum.push_back(s);
        }
        sort(strNum.begin(),strNum.end(),compare);

        for(int i=0;i<strNum.size();i++){
            result.append(strNum[i]);
        }
        return result;

    }
};

二叉搜索树的第K个节点知识点：二叉树遍历其实这道题比搜索二叉树转为双向链表还简单点，设置全局变量访问次数就好了

class Solution {
public:
    TreeNode* KthNode(TreeNode* pRoot, int k)
    {
        if (pRoot==NULL || k <0)
            return NULL;
        TreeNode* targetNode = NULL;
        midvisit(  pRoot,  k,&targetNode);
        return targetNode;
    }

    void  midvisit(TreeNode* pNode, int &k ,  TreeNode** targetNode)
    {
        if (pNode)
        {
            midvisit(pNode->left, k, targetNode);

            k--;
            if (k==0)
            {
                * targetNode =  pNode;
                return;
            }

            midvisit(pNode->right,  k,  targetNode);
        }
    }
};

二叉搜索树的后序遍历序列知识点：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        bool isafter = true;
        int length = sequence.size();

        if (length <= 1)
            return true;
        aftervisit(sequence, 0, length -1, isafter);
        return isafter;


    }

    void aftervisit(vector<int>& sequence, int begin, int end, bool &isafter)
    {
        if (begin==end)
            return ;

            int midvalue = sequence[end];

            int k = begin;
            for (; k<=end-1;k++)
            {
                if (sequence[k]>= midvalue)
                    break;
            }
            int rbegin = k;
            for(;rbegin<=end-1;rbegin++)
            {
                if (sequence[rbegin]<= midvalue)
                {
                    isafter = false;
                    return ;
                }
            }

            if (k -1>begin) aftervisit(sequence, begin, k-1 , isafter);
            if ( k  < end) aftervisit(sequence, k, end, isafter);


    }

};

翻转单词顺序列知识点：一个是要去掉单词前面的空格，一个是判断单词结尾了（空格或者句子结尾了）用str[end] =='\0' 或者注释掉的判断到句子结尾了

class Solution {

public:

string ReverseSentence(string str) {

if (str.size()<2)

return str;

reverse(str, 0, str.size()-1);

int begin = 0;

int end = 0;

int length = str.size();

for (;begin< length;)

{

if (str[begin] == ' ')

{

end++;

begin++;

}

else if (str[end] ==' '|| str[end] =='\0')

{

reverse(str, begin, end-1);

end++;

begin = end;

}

else

end++;

// if (end == length)

// {

// reverse(str, begin, end -1);

// break;

// }

}

return str;

}

void reverse(string& str, int begin, int end)

{

while(begin<end)

{

char ch = str[begin];

str[begin] = str[end];

str[end] = ch;

begin++;

end--;

}

};

替换空格知识点：字符串的复制知道题卡了很久，是这样的， for (int i = charCount-1,j = j-1 ; j>= 0;i--)这样子写的话j也是新建一个变量,与前面的变量j不是相同的，自己傻了

class Solution {
public:
    void replaceSpace(char *str,int length) {
        if(str == NULL || length <= 0)
            return;

        int spaceNumber = 0;
        int charNumber = 0;

        for (int i = 0; str[i] != '\0';i++)
        {
            charNumber++;
            if (str[i] == ' ')
                spaceNumber++;
        }


        int newIndex = charNumber + spaceNumber*2;
        int oldIndex = charNumber;
        if (newIndex>length)
            return;
        str[newIndex] = '\0';
        for (oldIndex--, newIndex--;oldIndex>=0;oldIndex--)
        {
            if (str[oldIndex] == ' ')
            {
                str[newIndex--] = '0';
                str[newIndex--] = '2';
                str[newIndex--] = '%';
            }
            else
            {
                str[newIndex--] = str[oldIndex];

            }   
        }


    }
};

树的子结构知识点：树的遍历

class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
    if (pRoot2==NULL || pRoot1 ==NULL)
        return false;
        bool isSub = true;
       visit(pRoot1, pRoot2, isSub);

        return isSub;

    }
    void visit(TreeNode* pRoot1,TreeNode* pRoot2,bool& flag)
    {
        if (pRoot1 == NULL)
            return ;
        if (pRoot1)
        {
            if (pRoot1->val == pRoot2->val)
            {
                isEqual(pRoot1,  pRoot2,  flag);
                if (flag)
                    return;
            } 
            visit(pRoot1->left, pRoot2, flag);
            visit(pRoot1->right, pRoot2, flag);
        }
    }   
    void isEqual(TreeNode* pRoot1, TreeNode* pRoot2, bool& flag)
    {
        if (pRoot1 == NULL || pRoot2 == NULL)
            return;
        else if (pRoot1 !=NULL && pRoot2 != NULL) 
        {
            if (pRoot1->val != pRoot2->val)
            {
                 flag = false;
                 return;
            }
            isEqual(pRoot1->left, pRoot2->left, flag);
            isEqual(pRoot1->right,pRoot2->right,flag);
        }
        else
        {
            flag = false;
            return;
        }
    }
};

链表中倒数第k个节点知识点：链表遍历

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
    if (pListHead == NULL)
        return NULL;
    int number = 0;
    ListNode* first = pListHead;
    ListNode* last =  NULL;

        while(first)
        {
            number++;
            if (number == k)
                break;
            first = first->next;
        }

        if (first==NULL)
            return NULL;
        last = pListHead;
        while(first->next)
        {
             first = first->next;
            last = last->next;
        }

        return last;
    }
};

反转链表

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        if (pHead == NULL || pHead->next == NULL)
            return pHead;

        ListNode * pre = pHead;
        ListNode* current = pHead->next;
        pre->next = NULL;
        while(current)
        {
            ListNode* next = current->next;
            current->next = pre;
            pre = current;
            current = next;
        }
        return pre;
    }
};

二维数组中的查找

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        bool found  = false;
        int columns = array.size()  ;
        vector<int> data = array[0];
        int rows = data.size() ;


            int row = 0;
            int column = columns - 1;
            while (row < rows && column >= 0)
            {
                vector<int> temp = array[row];

                if (temp[column] == target)
                {
                   found = true;
                    break;
                }

                else if (temp[column]> target)
                {
                    column--;
                }
                else
                    row++;
            }


        return found;

    }


};

0 0