寻找第K大的数

#include <stdio.h>
#include <stdlib.h>
int Left(int parent) {
  return parent * 2 + 1;
}
int Right(int parent) {
  return (parent + 1) * 2;
}
int Parent(int child) {
  return (child - 1) / 2;
}
template<typename T>
void Swap(T& left, T& right) {
  T tmp = left;
  left = right;
  right = tmp;
}
template<typename T>
void MinHeapfy(T array[], int parent, int length) {
  int min = parent;  
  if (Left(parent) < length && array[Left(parent)] < array[parent]) {
    min = Left(parent);
  }
  if (Right(parent) < length && array[Right(parent)] < array[min]) {
    min = Right(parent);
  }
  if (min != parent) {
    Swap(array[parent], array[min]);
    MinHeapfy(array, min, length);
  }
}
template<typename T>
bool HeapFinding(T array[], const T& target, int parent, int length) {
  bool left_match = Left(parent) < length && target == array[Left(parent)];
  bool right_match = Right(parent) < length && target == array[Right(parent)];
  if (left_match || right_match) {
    return true;
  }
  bool left_finded, right_finded;
  if (Left(parent) < length && array[Left(parent)] < target) {
    left_finded = HeapFinding(array, target, Left(parent), length);
  } else {
    left_finded = false;
  }
  if (Right(parent) < length && array[Right(parent)] < target) {
    right_finded = HeapFinding(array, target, Right(parent), length);
  } else {
    right_finded = false;
  }
  if (left_finded || right_finded) {
    return true;
  } else {
    return false;
  }
}
template<typename T>
T FindMaxK(T array[], int start, int end, int K) {
  if (K > 0) {
    int middle = (start + end) / 2;
    T average = (array[start] + array[middle] + array[end]) / 3;
    //    printf("%d\n", average);
    int j = start - 1;
    for (int i = start; i <= end; ++i) {
      if (array[i] <= average) {
        Swap(array[i], array[j + 1]);
        j++;
      }
    }
    int length = end - (j + 1) + 1;
    if (length > K) {
      return FindMaxK(array, j + 1, end, K);
    } else if(length == K) {
      return array[j + 1];
    } else {
      return FindMaxK(array, start, j, K - length);
    }
  } 
}
  
int main(int argc, char** argv) {
  const int kDataSize = 100;
  int array[kDataSize];
  for (int i = 0; i < kDataSize; ++i) {
    array[i] = rand() % 10;
    printf("%d\n", array[i]);
  }
  const int heap_size = 3;
  int heap[heap_size] = {0x80000001, 0x80000001,0x80000001};
  for (int i = 0; i < kDataSize; ++i) {
    if (array[i] > heap[0]) {
      if (!HeapFinding(heap, array[i], 0, heap_size)) {
        heap[0] = array[i];
        MinHeapfy(heap, 0, heap_size);
      }
    }
    /*    for (int i = 0; i < heap_size; ++i) {
      printf("%d ", heap[i]);
    }
    printf("\n");
    */
  }
  for (int i = 0; i < heap_size; ++i) {
    printf("%d ", heap[i]);
  }
  printf("\n");
  printf("max Kth = %d\n", FindMaxK(array, 0, kDataSize -1, 1));
}

参考文献：

编程之美2.5

http://www.cnblogs.com/jillzhang/archive/2007/10/04/913478.html