4949``` python
5050class Solution :
5151 def verifyPostorder (self postorder : List[int ]) -> bool :
52- def verify ( p1 , p2 ):
53- if p1 > p2 :
52+ def dfs ( postorder ):
53+ if not postorder :
5454 return True
55- pos = p1
56- while pos < p2 and postorder[pos] < postorder[p2]:
57- pos += 1
58- p = pos
59- while pos < p2:
60- if postorder[pos] < postorder[p2]:
61- return False
62- pos += 1
63- return verify(p1, p - 1 ) and verify(p, p2 - 1 )
64- if not postorder:
65- return True
66- return verify(0 , len (postorder) - 1 )
55+ v = postorder[- 1 ]
56+ i = 0
57+ while i < len (postorder) and postorder[i] < v:
58+ i += 1
59+ if any (x < v for x in postorder[i:]):
60+ return False
61+ return dfs(postorder[:i]) and dfs(postorder[i:- 1 ])
62+ 63+ return dfs(postorder)
6764```
6865
6966### ** Java**
@@ -73,21 +70,27 @@ class Solution:
7370``` java
7471class Solution {
7572 public boolean verifyPostorder (int [] postorder ) {
76- int n;
77- if (postorder == null || (n = postorder. length) == 0 ) return true ;
78- return verify(postorder, 0 , n - 1 );
73+ if (postorder == null || postorder. length < 2 ) {
74+ return true ;
75+ }
76+ return dfs(postorder, 0 , postorder. length);
7977 }
8078
81- private boolean verify (int [] postorder , int p1 , int p2 ) {
82- if (p1 >= p2) return true ;
83- int pos = p1;
84- while (pos < p2 && postorder[pos] < postorder[p2]) ++ pos;
85- int p = pos;
86- while (pos < p2) {
87- if (postorder[pos] < postorder[p2]) return false ;
88- ++ pos;
79+ private boolean dfs (int [] postorder , int i , int n ) {
80+ if (n <= 0 ) {
81+ return true ;
82+ }
83+ int v = postorder[i + n - 1 ];
84+ int j = i;
85+ while (j < i + n && postorder[j] < v) {
86+ ++ j;
87+ }
88+ for (int k = j; k < i + n; ++ k) {
89+ if (postorder[k] < v) {
90+ return false ;
91+ }
8992 }
90- return verify (postorder, p1, p - 1 ) && verify (postorder, p, p2 - 1 );
93+ return dfs (postorder, i, j - i ) && dfs (postorder, j, n + i - j - 1 );
9194 }
9295}
9396```
@@ -100,52 +103,48 @@ class Solution {
100103 * @return {boolean}
101104 */
102105var verifyPostorder = function (postorder ) {
103- if (! postorder || postorder .length < 2 ) return true ;
104- let mid = 0 ;
105- let root = postorder[postorder .length - 1 ];
106- for (let i = 0 ; i < postorder .length - 1 && postorder[i] < root; i++ ) {
107- mid++ ;
108- }
109- for (let i = mid + 1 ; i < postorder .length - 1 ; i++ ) {
110- if (postorder[i] < root) return false ;
106+ if (postorder .length < 2 ) return true ;
107+ function dfs (i , n ) {
108+ if (n <= 0 ) return true ;
109+ const v = postorder[i + n - 1 ];
110+ let j = i;
111+ while (j < i + n && postorder[j] < v) ++ j;
112+ for (let k = j; k < i + n; ++ k) {
113+ if (postorder[k] < v) {
114+ return false ;
115+ }
116+ }
117+ return dfs (i, j - i) && dfs (j, n + i - j - 1 );
111118 }
112- return (
113- verifyPostorder (postorder .slice (0 , mid)) &&
114- verifyPostorder (postorder .slice (mid + 1 , postorder .length - 1 ))
115- );
119+ return dfs (0 , postorder .length );
116120};
117121```
118122
119123### ** Go**
120124
121125``` go
122126func verifyPostorder (postorder []int ) bool {
123- if len (postorder) < 2 {
124- return true
125- }
126- return helper (postorder, 0 , len (postorder)-1 )
127- }
128- // 递归
129- func helper (postorder []int , left ,right int ) bool {
130- if left >= right {
131- return true
132- }
133- // 最后一位即根
134- rootValue := postorder[right]
135- // 从左开始往右遍历,直到大于根停止,小于部分是左子树
136- i := left
137- for i < right && postorder[i] < rootValue {
138- i++
139- }
140- // 剩下部分是右子树,检查是否都大于根值
141- for j := i; j < right; j++ {
142- if postorder[j] < rootValue {
143- return false
144- }
145- }
146- l := helper (postorder,left,i-1 ) // 检查左子树,左子树i要减一
147- r := helper (postorder,i,right-1 )// 检查右子树,剔除最后一位是根
148- return l && r
127+ if len (postorder) < 2 {
128+ return true
129+ }
130+ var dfs func (i, n int ) bool
131+ dfs = func (i, n int ) bool {
132+ if n <= 0 {
133+ return true
134+ }
135+ v := postorder[i+n-1 ]
136+ j := i
137+ for j < i+n && postorder[j] < v {
138+ j++
139+ }
140+ for k := j; k < i+n; k++ {
141+ if postorder[k] < v {
142+ return false
143+ }
144+ }
145+ return dfs (i, j-i) && dfs (j, n+i-j-1 )
146+ }
147+ return dfs (0 , len (postorder))
149148}
150149```
151150
@@ -155,25 +154,19 @@ func helper(postorder []int , left,right int) bool {
155154class Solution {
156155public:
157156 bool verifyPostorder(vector<int >& postorder) {
158- return verify(postorder, 0, postorder.size() - 1);
157+ if (postorder.size() < 2) return true;
158+ return dfs(postorder, 0, postorder.size());
159159 }
160160
161- bool verify(vector<int>& postorder, int left, int right) {
162- if (left >= right) {
163- return true;
164- }
165- int root = postorder[right], i = left;
166- while (postorder[i] < root) {
167- ++i;
168- }
169- int mid = i;
170- while (i < right) {
171- if (postorder[i] < root) {
172- return false;
173- }
174- ++i;
175- }
176- return verify(postorder, left, mid - 1) && verify(postorder, mid, right - 1);
161+ bool dfs(vector<int>& postorder, int i, int n) {
162+ if (n <= 0) return 1;
163+ int v = postorder[i + n - 1];
164+ int j = i;
165+ while (j < i + n && postorder[j] < v) ++j;
166+ for (int k = j; k < i + n; ++k)
167+ if (postorder[k] < v)
168+ return 0;
169+ return dfs(postorder, i, j - i) && dfs(postorder, j, n + i - j - 1);
177170 }
178171};
179172```
0 commit comments