文章目录

目录
- 第11题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python
- 第12题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python
- 第13 题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python
- 第 14题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python
- 第15 题：
- - 解题思路：
  - 代码实现：
  - - c++
    - - 递归实现
    - python
- 第16 题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python
- 第17题：
- - 解题思路：
  - 代码实现：
  - - c++
    - - 递归实现
    - python
- 第18题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python
- 第19题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python
- 第20 题：
- - 解题思路：
  - 代码实现：
  - - c++
    - python

#include <iostream>
#include <vector>
#include <cmath>using namespace std;double Power(double base, int exponent) {double temp = base;if(exponent < 0 ){for(int i =1 ;i<-(exponent);i++){temp *= base;}return 1.0/temp;}else if(exponent ==0){return 1;}else{for(int i = 1 ; i<exponent ; i++){temp *= base;}return temp;}}int main(){cout<<Power(2,-3)<<endl;cout<<Power(2,0)<<endl;cout<<Power(2,2)<<endl;return 0;
}

运行时间：5ms

占用内存：456k

python

# -*- coding:utf-8 -*-
class Solution:def Power(self, base, exponent):# write code herereturn base**exponent

运行时间：22ms
占用内存：5624k

第12题：

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有的奇数位于数组的前半部分，所有的偶数位于数组的后半部分，并保证奇数和奇数，偶数和偶数之间的相对位置不变。

解题思路：

通过使用2个栈结果来保存奇数项和偶数项,然后对数组从后向前遍历，遇到奇数就压奇数栈，遇到偶数就压偶数栈，然后在依次弹出奇数栈和偶数栈中的内容，并保存在原始的数组中（先将原始数组清空）

代码实现：

c++

#include <stack>
class Solution {public:void reOrderArray(vector<int> &array) {stack<int> oddStack;//定义奇数栈stack<int> evenStack;//定义偶数栈for(int i = array.size()-1 ; i >= 0 ;i--){if(array[i] % 2 == 0){evenStack.push(array[i]);}else{oddStack.push(array[i]);}}array.clear();while(!oddStack.empty()){array.push_back(oddStack.top());oddStack.pop();}while(!evenStack.empty()){array.push_back(evenStack.top());evenStack.pop();} }
};

运行时间：5ms

占用内存：480k

python

# -*- coding:utf-8 -*-
# -*- coding:utf-8 -*-
class Solution:def reOrderArray(self, array):# write code hereoddList = []  #保存奇数evenList = []  #保存偶数for i in array:if i % 2 == 0:evenList.append(i)else:oddList.append(i)array = []for i in oddList:array.append(i)for i in evenList:array.append(i)return array

运行时间：23ms

占用内存：5724k

第13 题：

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

解题思路：

首先顺序遍历一遍链表，并将值压栈，然后在通过栈弹出第K个元素即为链表的倒数第K个元素。时间复杂度为O(n),空间复杂度为O(n);

代码实现：

c++

/*
struct ListNode {int val;struct ListNode *next;ListNode(int x) :val(x), next(NULL) {}
};*/
class Solution {public:ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {stack<ListNode*> tempStack;if(pListHead == NULL){return NULL;}if(k <= 0){return NULL;}int dataCount = 0;while (pListHead != NULL){tempStack.push(pListHead);pListHead = pListHead->next;dataCount++;}if(dataCount < k){return NULL;}for(int i = 0 ; i < k - 1 ; i++){tempStack.pop();}return tempStack.top();}
};

运行时间：4ms

占用内存：476k

python

# -*- coding:utf-8 -*-
class Solution:def FindKthToTail(self, head, k):# write code hereres=[]while head:res.append(head)head=head.nextif k>len(res) or k<1:returnreturn res[-k]

运行时间：26ms
占用内存：5732k

第 14题：

输入一个链表，反转链表后，输出新链表的表头。

解题思路：

本体的意思应该是输出原始链表的反转链表，而不是仅仅只是输出反转后链表的头结点，所以通过栈的结构实现不佳。思想是：从头到尾遍历链表，然后将每两个节点进行反转操作即可，最好将原始的头结点的后继置NULL，头结点直接取最后一个元素

代码实现：

c++

class Solution {public:ListNode* ReverseList(ListNode* pListHead) {if(pListHead == NULL)return NULL;ListNode *pCurrent ,*pPre,*pNext;//一、指针的初始化阶段pPre = pListHead;pCurrent = pPre->next ;while(pCurrent)               //二、反转单链表的核心代码{pNext = pCurrent->next ;   //1. 缓冲pCurrent后面的单链表pCurrent->next = pPre ;       //2. 反转单链表pPre = pCurrent;           //3.让pPre指针后移pCurrent = pNext ;         //4. 让pCurrent指针后移}//三、处理并返回头指针pListHead->next = NULL;                //把原头结点的next域变成空指针pListHead = pPre ;                  //把头结点指向最后一个结点产生新的头结点，也就是把原单链表的尾结点变成头结点return pListHead;}
};

运行时间：5ms

占用内存：464k

python

# -*- coding:utf-8 -*-

第15 题：

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

解题思路：

递归的方法：依次在链表1和链表2遍历，每次取两个链表中较小的那个值插入到新的链表中去。

代码实现：

c++

递归实现

class Solution {public:ListNode* Merge(ListNode* pHead1, ListNode* pHead2){if(pHead1 == NULL && pHead2 == NULL){return NULL;}if(pHead1 == NULL){return pHead2;}if(pHead2 == NULL){return pHead1;}ListNode* head;  //新链表的表头if(pHead1->val < pHead2->val){head = pHead1;head->next =  Merge(pHead1->next , pHead2); //递归调用}else{head = pHead2;head->next =  Merge(pHead1, pHead2->next);}return head;}
};

运行时间：4ms

占用内存：492k

python

# -*- coding:utf-8 -*-

第16 题：

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

解题思路：

找一颗树是否为另外一颗树的子树，当然是遍历主树，先从根节点开始，如果根节点相同，就比较左右孩子节点，如果相同，则返回true，否则就递归遍历主树的左子树和右子树，只要找到一个相同即可。在比较子树和主树之前，我们要定义一个函数用于比较两个二叉树是否相同。也是从根节点开始，依次对比根节点，左孩子，右孩子是否相同，只有全部节点相同才是相同。

代码实现：

c++

class Solution {public:bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2){if(!pRoot1 || !pRoot2) return false;bool result=false;if(pRoot1->val == pRoot2->val)result=isSubtree(pRoot1,pRoot2); // 找到判断子树if(!result) result=HasSubtree(pRoot1->left,pRoot2); // 未找到匹配的根节点以及匹配的子树，则继续向下递归if(!result) result=HasSubtree(pRoot1->right,pRoot2);return result;}//判断2棵树是否相同bool isSubtree(TreeNode* pRoot1, TreeNode* pRoot2){if(!pRoot2) return true; // 子树遍历完成（关键语句）if(!pRoot1) return false; // 主树异常时的输出（关键语句：提高鲁棒性）bool result=true;if(pRoot1->val!=pRoot2->val) result=false; //根节点不同肯定不同if(result) result=isSubtree(pRoot1->left,pRoot2->left); //判断两颗树的左子树是否相同if(result) result=isSubtree(pRoot1->right,pRoot2->right);//判断两颗树的右子树是否相同return result;}
};

运行时间：3ms

占用内存：504k

python

# -*- coding:utf-8 -*-

第17题：

操作给定的二叉树，将其变换为源二叉树的镜像。

解题思路：

从题目中给出的例子可以看出，其实就是对树的每一层中双亲的左右孩子交换了一下。我们可以递归的访问树的每一层，然后交换每一层的双亲节点的左右孩子就可以。

递归的方法：先从根节点开始，交换根节点左右孩子节点，然后调用递归，依次遍历树的左子树和右子树，交换子树中的孩子节点。

代码实现：

c++

递归实现

class Solution {public:void Mirror(TreeNode *pRoot) {//递归推出条件if(pRoot==NULL){return;}//交换根节点的两个孩子TreeNode* tempNode;tempNode = pRoot->left;pRoot->left = pRoot->right;pRoot->right = tempNode;Mirror(pRoot->left);  //递归左子树Mirror(pRoot->right); //递归右子树}
};

运行时间：4ms

占用内存：468k

python

# -*- coding:utf-8 -*-
class Solution:# 返回镜像树的根节点def Mirror(self, root):# write code hereif root == None:return ;tempNode = TreeNode(-1)tempNode = root.leftroot.left = root.rightroot.right = tempNodeself.Mirror(root.left)self.Mirror(root.right)

运行时间：34ms

占用内存：5736k

第18题：

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

解题思路：

设定四个变量，分别指向行，列的起始点和终止点，然后将数据遍历分成4个节阶段，分别是：从左到右，从上到下，从右向左，从下到上，每个过程结束后，对应的指针都应该变化，循环执行，直到遍历完全部的数据。

代码实现：

c++

class Solution {public:vector<int> printMatrix(vector<vector<int> > matrix) {vector<int>res;  //用来保存遍历过的数据res.clear(); int row=matrix.size();//行数int collor=matrix[0].size();//列数//计算打印的圈数int circle=((row<collor?row:collor)-1)/2+1;//圈数for(int i=0;i<circle;i++){//从左向右打印for(int j=i;j<collor-i;j++)res.push_back(matrix[i][j]);         //从上往下的每一列数据for(int k=i+1;k<row-i;k++)res.push_back(matrix[k][collor-1-i]);//判断是否会重复打印(从右向左的每行数据)for(int m=collor-i-2;(m>=i)&&(row-i-1!=i);m--)res.push_back(matrix[row-i-1][m]);//判断是否会重复打印(从下往上的每一列数据)for(int n=row-i-2;(n>i)&&(collor-i-1!=i);n--)res.push_back(matrix[n][i]);}return res;}
};

运行时间：4ms

占用内存：468k

python

# -*- coding:utf-8 -*-

第19题：

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））

解题思路：

定义一个辅助栈，这个栈顶元素始终是最小值。

代码实现：

c++

class Solution {public:stack<int> stack1,stack2;void push(int value) {stack1.push(value);//两种情况下才将元素压入辅助栈中if(stack2.empty())stack2.push(value);else if(value<=stack2.top()){stack2.push(value);}}void pop() {if(stack1.top()==stack2.top())stack2.pop();stack1.pop();}int top() {return stack1.top();       }int min() {return stack2.top();}};

运行时间：2ms

占用内存：472k

python

# -*- coding:utf-8 -*-
class Solution:def __init__(self):self.data = []self.minData = []def push(self, node):# write code hereself.data.append(node)if self.minData == [] or node < self.minData[-1]:self.minData.append(node)def pop(self):# write code hereif self.data[-1] == self.minData[-1]:self.minData.pop()self.data.pop()def top(self):# write code herereturn self.data[-1]def min(self):# write code herereturn self.minData[-1]

运行时间：31ms

占用内存：5624k

第20 题：

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

解题思路：

借用一个辅助的栈，遍历压栈顺序，先讲第一个放入栈中，这里是1，然后判断栈顶元素是不是出栈顺序的第一个元素，这里是4，很显然1≠4，所以我们继续压栈，直到相等以后开始出栈，出栈一个元素，则将出栈顺序向后移动一位，直到不相等，这样循环等压栈顺序遍历完成，如果辅助栈还不为空，说明弹出序列不是该栈的弹出顺序。

举例：

入栈1,2,3,4,5

出栈4,5,3,2,1

首先1入辅助栈，此时栈顶1≠4，继续入栈2

此时栈顶2≠4，继续入栈3

此时栈顶3≠4，继续入栈4

此时栈顶4＝4，出栈4，弹出序列向后一位，此时为5，,辅助栈里面是1,2,3

此时栈顶3≠5，继续入栈5

此时栈顶5=5，出栈5,弹出序列向后一位，此时为3，,辅助栈里面是1,2,3

….

依次执行，最后辅助栈为空。如果不为空说明弹出序列不是该栈的弹出顺序

代码实现：

c++

class Solution {public:bool IsPopOrder(vector<int> pushV,vector<int> popV) {if(pushV.size() == 0) return false;  vector<int> stack;for(int i = 0,j = 0 ;i < pushV.size();){stack.push_back(pushV[i++]);while(j < popV.size() && stack.back() == popV[j]){  //当辅助栈的栈顶元素与弹出栈的相同，则将辅助栈的元素弹出，同时继续遍历弹出栈stack.pop_back();j++;}      }return stack.empty();}
};

运行时间：3ms

占用内存：380k

python

# -*- coding:utf-8 -*-