面试常用排序算法

public class Sort {
// 插入排序
public void insertSort(int array[], int length) {
// 从1开始遍历
for (int i = 1; i < length; i++) {
int j = i - 1;
//temp用来记录需要插入的值
int temp = array[i];
for (; j >= 0 && temp < array[j]; j--) {
// 整体后移
array[j + 1] = array[j];
}
//因为最后结束的时候，j又被剪了一次，所以j要加1
// 插入
array[j + 1] = temp;
}
}

// 冒泡排序
public void bubbleSort(int array[], int length) {
for (int i = 0; i < length; i++) {
// 核心点在于j < length - 1 - i
for (int j = 0; j < length - 1 - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}

// 直接选择排序
public void selectSort(int array[], int length) {
// 外层循环是n-1次
for (int i = 0; i < length - 1; i++) {
int min = i;
// 从i+1到最后选择出一个最小的
for (int j = i + 1; j < length; j++) {
if (array[j] < array[min]) {
min = j;
}
}
// 互换
if (min != i) {
int temp = array[i];
array[i] = array[min];
array[min] = temp;
}
}
}

// 快速排序之分组
public int partition(int array[], int low, int high) {
int pivot = array[low];
// 双while结构
while (low < high) {
//右侧的比pivot大，high指针向左移动
while (low < high && array[high] >= pivot)
high--;
//此时右侧的比pivot小了
if (low < high)
//互换，并且low指针向右移动
array[low++] = array[high];
while (low < high && array[low] <= pivot)
low++;
if (low < high)
array[high--] = array[low];
}
array[low] = pivot;
return low;
}

// 快速排序
public void quickSort(int array[], int low, int high) {
int dp;
if (low < high) {
// 分治法
dp = partition(array, low, high);
//快排左侧
quickSort(array, low, dp - 1);
//快排右侧
quickSort(array, dp + 1, high);
}
}

public void buildMaxHeap(int array[]) {
int half = array.length / 2;
for (int i = half; i >= 0; i--) {
//每个非叶子结点都要建一个大顶堆
maxHeap(array, array.length, i);
}
}

//建立大顶堆的过程
private void maxHeap(int[] array, int length, int i) {
int left = i * 2 + 1;
int right = i * 2 + 2;

int largest = i;
if (left < length && array[left] > array[i]) {
largest = left;
}
if (right < length && array[right] > array[largest]) {
largest = right;
}
// 大的换上去
if (i != largest) {
int temp = i;
i = largest;
largest = temp;
// 此刻的largest就是被换下来的i
maxHeap(array, length, largest);
}
}

// 堆排序
public void heapSort(int array[]) {
// 建立大顶堆
buildMaxHeap(array);

for (int i = array.length - 1; i >= 1; i--) {
// 把最大的放到最后
int tmp = array[0];
array[0] = array[i];
array[i] = tmp;

//i是数组长度，出去已经排完序的，0是要被调整的结点的index
maxHeap(array, i, 0);
}
}

//希尔排序
public void shellSort(int array[]) {
//增量每次变为原来的0.5
for (int increment = array.length/2; increment > 0; increment /= 2) {
//每一个分组里的每个数都要比较
for(int i = 0;i<increment;i++){
//插入排序--本质
for(int j = i + increment;j<array.length;j+=increment){
if(array[j]<array[j-increment]){
//存下来需要插入的数
int temp = array[j];
int k = j-increment;
for(;k>=0 && temp < array[k];k-=increment){
array[k+increment] = array[k];
}
array[k+increment] = temp;
}
}
}
}
}

//排序
public int[] sort(int array[],int low,int high){
int mid = (low + high) /2;
sort(array,low,mid);
sort(array,mid + 1,high);
//将排完序的左侧和右侧合并起来
merge(array,low,mid,high);
return array;
}
//归并
public void merge(int array[],int low,int mid,int high){
int temp[] = new int[high -low +1];
int i = low;
int j = mid + 1;
int k = 0;

//小的进去
while (i <= mid && j <= high) {
if (array[i] < array[j]) {
temp[k++] = array[i++];
} else {
temp[k++] = array[j++];
}
}

while(i<= mid){
temp[k++] = array[i++];
}

while(j<= high){
temp[k++] = array[j++];
}

for(int m = 0;m<temp.length;m++){
array[low + m] = temp[m];
}
}

//二分查找法 必须是对已经排好序的进行
public int binarySearch(int array[],int des){
int low = 0;
int upper = array.length-1;
while(low <= upper){
int mid = (low + upper) / 2;
if(array[mid] <des){
low = mid + 1;
}else if(array[mid]>des){
upper = mid - 1;
}else
return mid;
}
return -1;
}
}