算法导论第9章中位数和顺序统计学

#include <iostream>
#include <stdint.h>
#ifdef __linux
#include <stdio.h>
#endif
// MINIMUM(A)
// MIN = A[1]
// for i = 2 to A.length
//     if min > A[i]
//         min = A[i]
// return min

int64_t minimum(int64_t* A, int64_t n)
{
int64_t min = A[0];
for (int64_t i = 0; i < n; i++)
{
if (min > A[i])
{
min = A[i];
}
}
return min;
}

int64_t maximum(int64_t* A, int64_t n)
{
int64_t max = A[0];
for (int64_t i = 0; i < n; i++)
{
if (max < A[i])
{
max = A[i];
}
}
return max;
}

class MaxMin {
public:
int64_t min;
int64_t max;
};

MaxMin maxminmum(int64_t* A, int64_t n)
{
MaxMin maxmin;
if (0 == n % 2)
{
if (A[0] > A[1])
{
maxmin.min = A[1];
maxmin.max = A[0];
}
else
{
maxmin.min = A[0];
maxmin.max = A[1];
}
for (int64_t i = 2; i < n - 1; i+=2)
{
if (A[i] > A[i + 1])
{
if (A[i] > maxmin.max)
{
maxmin.max = A[i];
}
if (A[i + 1] < maxmin.min)
{
maxmin.min = A[i + 1];
}
}
else
{
if (A[i + 1] > maxmin.max)
{
maxmin.max = A[i + 1];
}
if (A[i] < maxmin.min)
{
maxmin.min = A[i];
}
}
}
}
else
{
maxmin.max = maxmin.min = A[0];
for (int64_t i = 1; i < n - 1; i+=2)
{
if (A[i] > A[i + 1])
{
if (A[i] > maxmin.max)
{
maxmin.max = A[i];
}
if (A[i + 1] < maxmin.min)
{
maxmin.min = A[i + 1];
}
}
else
{
if (A[i + 1] > maxmin.max)
{
maxmin.max = A[i + 1];
}
if (A[i] < maxmin.min)
{
maxmin.min = A[i];
}
}
}

}
return maxmin;
}

int main()
{
// even number array
int64_t array0[6] = { 5, 2, 4, 6, 1, 3 };
int64_t min = minimum(array0, sizeof(array0) / sizeof(int64_t));
std::cout << min << std::endl;
int64_t max = maximum(array0, sizeof(array0) / sizeof(int64_t));
std::cout << max << std::endl;

MaxMin maxmin = maxminmum(array0, sizeof(array0) / sizeof(int64_t));
std::cout << maxmin.min << std::endl;
std::cout << maxmin.max << std::endl;

// not even number array
int64_t array1[7] = { 5, 2, 4, 6, 1, 3, 10 };
min = minimum(array1, sizeof(array1) / sizeof(int64_t));
std::cout << min << std::endl;
max = maximum(array1, sizeof(array1) / sizeof(int64_t));
std::cout << max << std::endl;

maxmin = maxminmum(array1, sizeof(array1) / sizeof(int64_t));
std::cout << maxmin.min << std::endl;
std::cout << maxmin.max << std::endl;

getchar();
return 0;
}

BIN     = bin
FMCSA   = find_max_crossing_subarray
IAS     = IA_solution
IST     = insertion_sort_t
LMSA    = liner_time_max_subarray
MERGE   = merge
MERGE_T = merge_t
VMS     = violate_max_subarray
STRA    = 4.2_strassen
COUNT_SORT = 8.2_counting_sort
MINIMUMMAXIMUM = 9.1_MinimumMaximum

CFLAGS = -Wall

all : ${BIN}/${COUNT_SORT} ${BIN}/${FMCSA} ${BIN}/${IAS} ${BIN}/${IST} ${BIN}/${LMSA} ${BIN}/${MERGE} ${BIN}/${MERGE_T} ${BIN}/${VMS} ${BIN}/${STRA} ${BIN}/${MINIMUMMAXIMUM}

${BIN}/${COUNT_SORT} : ${COUNT_SORT}/counting_sort.cpp
g++ ${COUNT_SORT}/counting_sort.cpp ${CFLAGS} -o ${BIN}/${COUNT_SORT}

${BIN}/${FMCSA} : ${FMCSA}/main.cpp ${FMCSA}/max_sub_array.h
g++ ${FMCSA}/main.cpp ${CFLAGS} -o ${BIN}/${FMCSA}

${BIN}/${IAS} : ${IAS}/insertion_sort.cpp ${IAS}/insertion_sort.h
g++ ${IAS}/insertion_sort.cpp ${CFLAGS} -o ${BIN}/${IAS}

${BIN}/${IST} : ${IST}/${IST}.cpp ${IST}/${IST}.h
g++ ${IST}/${IST}.cpp ${CFLAGS} -o ${BIN}/${IST}

${BIN}/${LMSA} : ${LMSA}/Source.cpp
g++ ${LMSA}/Source.cpp ${CFLAGS} -o ${BIN}/${LMSA}

${BIN}/${MERGE} : ${MERGE}/${MERGE}.cpp  ${MERGE}/${MERGE}.h
g++ -std=c++0x ${MERGE}/${MERGE}.cpp ${CFLAGS} -o ${BIN}/${MERGE}

${BIN}/${MERGE_T} : ${MERGE_T}/${MERGE_T}.cpp  ${MERGE_T}/${MERGE_T}.h
g++ -std=c++0x ${MERGE_T}/${MERGE_T}.cpp ${CFLAGS} -o ${BIN}/${MERGE_T}

${BIN}/${VMS} : ${VMS}/Source.cpp
g++ ${VMS}/Source.cpp ${CFLAGS} -o ${BIN}/${VMS}

${BIN}/${STRA} : ${STRA}/strassen.cpp ${STRA}/strassen.h
g++ -std=c++0x ${STRA}/strassen.cpp ${CFLAGS} -o ${BIN}/${STRA}

${BIN}/${MINIMUMMAXIMUM} : ${MINIMUMMAXIMUM}/${MINIMUMMAXIMUM}.cpp
g++ ${MINIMUMMAXIMUM}/${MINIMUMMAXIMUM}.cpp ${CFLAGS} -o ${BIN}/${MINIMUMMAXIMUM}
clean:
rm ${BIN}/*