锘??xml version="1.0" encoding="utf-8" standalone="yes"?>
/**/
/*
test聽case:
2*(3+4)-8/2
(2*3+(2+5*2-10))/(8/2)
15+10*(50*2-5)/2
15+10*(50*2-5)/3
1.5*2.3*(3.7-2.13*3.2)-8.0
*/
#include聽
<
聽stdio.h聽
>
#include聽
<
聽
string
.h聽
>
#define
聽N聽1000
char
聽b[N],c,stack[
100
];
int
聽bn,sn,isnum,endflag
=
0
;
void
聽midtoback()
{
聽聽聽聽bn
=
0
;
聽聽聽聽sn
=-
1
;
聽聽聽聽isnum
=
0
;
聽聽聽聽
while
((c
=
getchar())
!=
EOF
&&
c
!=
'
\n
'
)
聽聽聽聽
{
聽聽聽聽聽聽聽聽
switch
(c)
聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽
case
聽
'
(
'
:
聽聽聽聽聽聽聽聽聽聽聽聽
if
(isnum
==
1
)聽b[bn
++
]
=
'
,
'
;
聽聽聽聽聽聽聽聽聽聽聽聽isnum
=
2
;
聽聽聽聽聽聽聽聽聽聽聽聽stack[
++
sn]
=
'
(
'
;
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽
case
聽
'
)
'
:
聽聽聽聽聽聽聽聽聽聽聽聽
if
(isnum
==
1
)聽b[bn
++
]
=
'
,
'
;
聽聽聽聽聽聽聽聽聽聽聽聽isnum
=
2
;
聽聽聽聽聽聽聽聽聽聽聽聽
while
(sn
>=
0
&&
stack[sn]
!=
'
(
'
)
聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽b[bn
++
]
=
stack[sn
--
];
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽stack[sn
+
1
]
=
0
;
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽stack[sn
--
]
=
0
;
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽
case
聽
'
+
'
:
聽聽聽聽聽聽聽聽聽聽聽聽
if
(isnum
==
1
)聽b[bn
++
]
=
'
,
'
;
聽聽聽聽聽聽聽聽聽聽聽聽isnum
=
2
;
聽聽聽聽聽聽聽聽聽聽聽聽
while
(sn
>=
0
&&
stack[sn]
!=
'
(
'
)
聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽b[bn
++
]
=
stack[sn
--
];
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽stack[sn
+
1
]
=
0
;
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽stack[
++
sn]
=
'
+
'
;
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽
case
聽
'
-
'
:
聽聽聽聽聽聽聽聽聽聽聽聽
if
(isnum
==
1
)聽b[bn
++
]
=
'
,
'
;
聽聽聽聽聽聽聽聽聽聽聽聽isnum
=
2
;
聽聽聽聽聽聽聽聽聽聽聽聽
while
(sn
>=
0
&&
stack[sn]
!=
'
(
'
)
聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽b[bn
++
]
=
stack[sn
--
];
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽stack[sn
+
1
]
=
0
;
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽stack[
++
sn]
=
'
-
'
;
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽
case
聽
'
*
'
:
聽聽聽聽聽聽聽聽聽聽聽聽
if
(isnum
==
1
)聽b[bn
++
]
=
'
,
'
;
聽聽聽聽聽聽聽聽聽聽聽聽isnum
=
2
;
聽聽聽聽聽聽聽聽聽聽聽聽
while
(sn
>=
0
&&
stack[sn]
!=
'
(
'
&&
stack[sn]
!=
'
+
'
&&
stack[sn]
!=
'
-
'
)
聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽b[bn
++
]
=
stack[sn
--
];
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽stack[sn
+
1
]
=
0
;
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽stack[
++
sn]
=
'
*
'
;
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽
case
聽
'
/
'
:
聽聽聽聽聽聽聽聽聽聽聽聽
if
(isnum
==
1
)聽b[bn
++
]
=
'
,
'
;
聽聽聽聽聽聽聽聽聽聽聽聽isnum
=
2
;
聽聽聽聽聽聽聽聽聽聽聽聽
while
(sn
>=
0
&&
stack[sn]
!=
'
(
'
&&
stack[sn]
!=
'
+
'
&&
stack[sn]
!=
'
-
'
)
聽聽聽聽聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽b[bn
++
]
=
stack[sn
--
];
聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽stack[sn
+
1
]
=
0
;
聽聽聽聽聽聽聽聽聽聽聽聽}
聽聽聽聽聽聽聽聽聽聽聽聽stack[
++
sn]
=
'
/
'
;
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽
default
:
聽聽聽聽聽聽聽聽聽聽聽聽isnum
=
1
;
聽聽聽聽聽聽聽聽聽聽聽聽b[bn
++
]
=
c;
聽聽聽聽聽聽聽聽聽聽聽聽
break
;
聽聽聽聽聽聽聽聽}
聽聽聽聽}
聽聽聽聽
while
(sn
>=
0
)
聽聽聽聽聽聽聽聽b[bn
++
]
=
stack[sn
--
];
聽聽聽聽
if
(c
!=
'
\n
'
)聽endflag
=
1
;
}
int
聽main()
{
聽聽聽聽
while
(endflag
==
0
)
聽聽聽聽
{
聽聽聽聽聽聽聽聽memset(stack,
0
,
sizeof
(stack));
聽聽聽聽聽聽聽聽memset(b,
0
,
sizeof
(b));
聽聽聽聽聽聽聽聽midtoback();
聽聽聽聽聽聽聽聽printf(
"
%s\n
"
,b);
聽聽聽聽}
聽聽聽聽
return
聽
0
;
}
聽聽聽聽聽聽聽聽
]]>#include聽<stdio.h>
template聽<聽class聽T聽>
void聽mergeSort(聽T聽*a,聽int聽size聽)
{
聽聽聽聽int聽*b=new聽T[size];
聽聽聽聽mergePass(a,b,0,size-1);
}
template聽<聽class聽T聽>
void聽mergePass(聽T聽*a,聽T聽*b,聽int聽l,聽int聽r聽)
{
聽聽聽聽int聽m;
聽聽聽聽if(l<r)
聽聽聽聽
{
聽聽聽聽聽聽聽聽m=(l+r)/2;
聽聽聽聽聽聽聽聽mergePass(a,b,l,m);
聽聽聽聽聽聽聽聽mergePass(a,b,m+1,r);
聽聽聽聽聽聽聽聽merge(a,b,l,m,r);
聽聽聽聽聽聽聽聽copy(a,b,l,r);
聽聽聽聽}
}
template聽<聽class聽T聽>
void聽merge(聽T聽*a,聽T聽*b,聽int聽l,聽int聽m,聽int聽r聽)
{
聽聽聽聽int聽i=l,j=m+1;
聽聽聽聽while(i<=m&&j<=r)
聽聽聽聽
{
聽聽聽聽聽聽聽聽if(a[i]<=b[j])
聽聽聽聽聽聽聽聽聽聽聽聽b[l++]=a[i++];
聽聽聽聽聽聽聽聽else
聽聽聽聽聽聽聽聽
{
聽聽聽聽聽聽聽聽聽聽聽聽b[l++]=a[j++];
聽聽聽聽聽聽聽聽聽聽聽聽//num+=m-i+1;
聽聽聽聽聽聽聽聽聽聽聽聽//鐢ㄥ綊騫舵帓搴忔眰閫嗗簭鏁板垯鍦ㄨ繖閲屾坊鍔犺繖鍙ヨ瘽錛宯um涓哄叏灞鍙橀噺
聽聽聽聽聽聽聽聽聽聽聽聽//num+=鍓嶈礬榪樻病鏈夊綊騫剁殑闀垮害+1
聽聽聽聽聽聽聽聽}
聽聽聽聽}
聽聽聽聽while(i<=m)
聽聽聽聽聽聽聽聽b[l++]=a[i++];
聽聽聽聽while(j<=r)
聽聽聽聽聽聽聽聽b[l++]=a[j++];
}
template聽<聽class聽T聽>
void聽copy(聽T聽*a,聽T聽*b,聽int聽l,聽int聽r聽)
{
聽聽聽聽while(l<=r)
聽聽聽聽
{
聽聽聽聽聽聽聽聽a[l]=b[l];
聽聽聽聽聽聽聽聽l++;
聽聽聽聽}
}
int聽main()
{
聽聽聽聽int聽a[10]=
{10,9,8,7,6,5,4,3,2,1},i;
聽聽聽聽mergeSort(a,10);
聽聽聽聽for(i=0;i<10;i++)
聽聽聽聽聽聽聽聽printf("%d聽",a[i]);
聽聽聽聽putchar('\n');
聽聽聽聽return聽0;
}
]]>
]]>