# 常见经典排序算法的java实现

public class Sort {
// =======================选择排序Begin========================
void select_sort(int[] array) {

for (int i = 0; i < array.length - 1; i++) {
int minIndex = i;

for (int j = i + 1; j < array.length; j++) {

if (array[minIndex] > array[j]) {
minIndex = j;
}
}

if (minIndex != i) {
int temp = array[minIndex];
array[minIndex] = array[i];
array[i] = temp;
}
}
}

// =======================选择排序End===========================
// =======================冒泡排序——大泡下沉Begin=============
void bubble_sort(int[] array) {

for (int i = array.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
int temp = 0;
if (array[j] > array[j + 1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}

// ======================冒泡排序——大泡下沉End================
// ======================冒泡排序——小泡上浮Begin==============
void bubbleSort(int[] array) {

for (int i = 0; i < array.length; i++) {
for (int j = array.length - 1; j > i; j--) {
int temp = 0;
if (array[j] < array[j - 1]) {
temp = array[j];
array[j] = array[j - 1];
array[j - 1] = temp;
}
}
}
}

// ======================冒泡排序——小泡上浮End================
// ======================直接插入排序Begin======================
void insertion_sort(int[] unsorted) {
for (int i = 1; i < unsorted.length; i++) {
if (unsorted[i - 1] > unsorted[i]) {
int temp = unsorted[i];
int j = i;
while (j > 0 && unsorted[j - 1] > temp) {
unsorted[j] = unsorted[j - 1];
j--;
}
unsorted[j] = temp;
}
}
}

// =======================直接插入排序End======================

// ========================快速排序1Begin======================
int partition(int[] unsorted, int low, int high) {

int pivot = unsorted[low];

while (low < high) {

while (low < high && unsorted[high] > pivot)
high--;

unsorted[low] = unsorted[high];

while (low < high && unsorted[low] <= pivot)
low++;

unsorted[high] = unsorted[low];
}

unsorted[low] = pivot;

return low;
}

void quick_sort(int[] unsorted, int low, int high) {

int loc = 0;

if (low < high) {

loc = partition(unsorted, low, high);

quick_sort(unsorted, low, loc - 1);

quick_sort(unsorted, loc + 1, high);
}
}

// =======================快速排序1End========================

// =======================快速排序2Begin======================

// 快速排序一次划分
int Partition(int r[], int first, int end) {
int i = first; // 初始化
int j = end;
int temp;

while (i < j) {
while (i < j && r[i] <= r[j])
j--; // 右侧扫描
if (i < j) {
temp = r[i]; // 将较小记录交换到前面
r[i] = r[j];
r[j] = temp;
i++;
}
while (i < j && r[i] <= r[j])
i++; // 左侧扫描
if (i < j) {
temp = r[j];
r[j] = r[i];
r[i] = temp; // 将较大记录交换到后面
j--;
}
}
return i; // i为轴值记录的最终位置
}

// 快速排序
void QuickSort(int r[], int first, int end) {
if (first < end) { // 递归结束
int pivot = Partition(r, first, end); // 一次划分
QuickSort(r, first, pivot - 1); // 递归地对左侧子序列进行快速排序
QuickSort(r, pivot + 1, end); // 递归地对右侧子序列进行快速排序
}

}

// =======================快速排序2End========================

// =======================堆排序1Begin========================
// array是待调整的堆数组,i是待调整的数组元素的位置,length是数组的长度
void HeapAdjust(int array[], int i, int nLength) {
int nChild, nTemp;

for (nTemp = array[i]; 2 * i + 1 < nLength; i = nChild) {

// 子结点的位置是 父结点位置 * 2 和父节点位置*2+1 // 修改处
nChild = 2 * i + 1;

// 得到子结点中较大的结点
if (nChild != nLength - 1 && array[nChild + 1] > array[nChild])
++nChild;

// 如果较大的子结点大于父结点那么把较大的子结点往上移动,替换它的父结点
if (nTemp < array[nChild]) {
array[i] = array[nChild];
} else // 否则退出本次循环
{
break;
}
}

// 最后把需要调整的元素值放到合适的位置
array[i] = nTemp;
}

// 堆排序算法
void HeapSort(int array[], int length) {

// 调整序列的前半部分元素,调整完之后第一个元素是序列的最大的元素
for (int i = length / 2 - 1; i >= 0; --i) {
}

// 从最后一个元素开始对序列进行调整,不断的缩小调整的范围直到第一个元素4
for (int i = length - 1; i > 0; --i) {

// 把第一个元素和当前的最后一个元素交换,保证当前的最后一个位置的元素都是在现在的这个序列之中最大的
int tem = array[0];
array[0] = array[i];
array[i] = tem;

// 不断缩小调整heap的范围,每一次调整完毕保证第一个元素是当前序列的最大值
}
}

// =========================堆排序1End==============================

// =========================堆排序2Begin============================
void heapAdjust(int a[], int i, int n) {
int tem;
int min_p = 2 * i;
if (2 * i < n) {
min_p = 2 * i;
}
if (2 * i + 1 < n) {
if (a[2 * i + 1] > a[2 * i]) {
min_p = 2 * i + 1;
}
}
if (a[min_p] > a[i]) {
tem = a[min_p];
a[min_p] = a[i];
a[i] = tem;
if (2 * min_p < n)
}

}

void Heap_sort(int a[], int n) {
int i, tem;
for (i = n / 2 - 1; i >= 0; i--) {
}
for (i = 0; i < n - 1; i++) {
tem = a[0];
a[0] = a[n - i - 1];
a[n - i - 1] = tem;
heapAdjust(a, 0, n - i - 1);
}
}

// ========================堆排序2End========================

// ========================基数排序Begin=====================
/**
* 基数排序 结合桶式排序，分两种从高位到低位和从低位到高位。案例代码为从低位到高位 第一步：得到数组内最大位数 第二步：进行多次
* 桶式排序，次数为排序最大数字的位数 例子：52,38,23,72,271 第一步：数组元素最大位数为3,
* 第二步：第一次桶式排序，针对数组元素的个位：排序结果为：271，52,72,23,38，按个位桶式排序就完成了 继续：
* 第二次桶式排序，按照数组元素的十位：排序结果为：23,38,52,271,72 继续：
* 第三次桶式排序，按照数组元素的百位：排序结果为：23,38,52,72,271 排序完成。
*
* @author
*
*/
int maxW = 0;
int index = 0;

// 第一步：得到数组内最大元素的位数
for (int i = 0; i < array.length; i++) {
if (maxW < array[i]) {
maxW = array[i];
}
}

maxW = getNumberLength(maxW);

// 第二步：进行多次 桶式排序，次数为排序最大数字的位数
while (index < maxW) {
int[] tempArray = new int[array.length];
int[] bucketArray = new int[10];
System.arraycopy(array, 0, tempArray, 0, array.length);
for (int i = 0; i < array.length; i++) {
bucketArray[getNumberIndex(index, array[i])]++;
}

for (int i = 1; i < bucketArray.length; i++) {
bucketArray[i] = bucketArray[i] + bucketArray[i - 1];
}
for (int i = array.length - 1; i >= 0; i--) {
array[--bucketArray[getNumberIndex(index, tempArray[i])]] = tempArray[i];
}
index++;
}
}

int getNumberIndex(int index, int number) {
int num = 0;
num = (int) (number / Math.pow(10, index)) % 10;
return num;
}

int getNumberLength(int number) {
int count = 1;
int index = 1;
while ((number - Math.pow(10, index)) > 0) {// Math.pow(x,y)计算x的y次幂
count++;
index++;
}
return count;
}

// =======================基数排序End==========================

// =======================归并排序Begin========================
//将有二个有序数列a[first...mid]和a[mid...last]合并。
void merge(int[] unsorted, int first, int mid, int last, int[] sorted) {
int i = first, j = mid;
int k = 0;
while (i < mid && j < last)
if (unsorted[i] < unsorted[j]) {
sorted[k++] = unsorted[i++];
} else if (unsorted[i] > unsorted[j]) {
sorted[k++] = unsorted[j++];
} else {
sorted[k++] = unsorted[i++];
sorted[k++] = unsorted[j++];
}
while (i < mid)
sorted[k++] = unsorted[i++];
while (j < last)
sorted[k++] = unsorted[j++];

for (int v = 0; v < k; v++)
unsorted[first + v] = sorted[v];
}

void merge_sort(int[] unsorted, int first, int last, int[] sorted) {
if (first + 1 < last) {
int mid = (first + last) / 2;
merge_sort(unsorted, first, mid, sorted);//左边有序
merge_sort(unsorted, mid, last, sorted);//右边有序
merge(unsorted, first, mid, last, sorted);//再将二个有序数列合并
}
}

// =========================归并排序End========================

// =========================希尔排序Begin======================
void shell_sort(int[] array) {
int groupLen = 0;
int len = array.length;
for (groupLen = len / 2; groupLen > 0; groupLen /= 2) {
for (int i = 0; i < len - groupLen; i++) {
for (int j = i; j < len - groupLen; j += groupLen) {
if (array[j] > array[j + groupLen]) {
int temp = array[j];
array[j] = array[j + groupLen];
array[j + groupLen] = temp;
}
}
}
}
}

// =====================希尔排序End==========================

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub

Sort sort = new Sort();

System.out
.println("*********************选择排序*********************");
int[] selectArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
sort.select_sort(selectArray);
print(selectArray);

System.out
.println("*********************冒泡排序**********************");
int[] bubbleArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
sort.bubble_sort(bubbleArray);
// sort.bubbleSort(bubbleArray);
print(bubbleArray);

System.out
.println("*********************直接插入排序******************");
int[] x = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
sort.insertion_sort(x);
print(x);

System.out
.println("*********************快速排序**********************");
int[] quickArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
// sort.quick_sort(x, 0, x.length - 1);
sort.QuickSort(quickArray, 0, quickArray.length - 1);
print(quickArray);

System.out
.println("*********************堆排序************************");
int a[] = { 71, 18, 151, 138, 160, 63, 174, 169, 79, 78 };
sort.HeapSort(a, a.length);
// sort.Heap_sort(a, a.length);
print(a);

System.out
.println("*********************基数排序***********************");
int[] array = new int[] { 51, 82, 23, 94, 35, 76, 117, 238, 909, 40, 11 };
print(array);

System.out
.println("*********************归并排序***********************");
int[] mergeArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
int[] sorted = new int[mergeArray.length];
sort.merge_sort(mergeArray, 0, mergeArray.length, sorted);
print(mergeArray);

System.out
.println("*********************希尔排序***********************");
int[] shellArray = { 6, 3, 2, 7, 4, 8, 1, 5, 9 };
sort.shell_sort(shellArray);
print(shellArray);
}

static void print(int[] a) {
for (int i = 0; i < a.length; i++) {
if (i == a.length - 1)
System.out.println(a[i]);
else
System.out.print(a[i] + ",");
}
System.out
.println("**********************end****************************");
}
}

#### Java的几种经典排序算法

2016-12-29 00:18:02

#### 几种经典排序算法的Java实现

2011年11月21日 268KB 下载

#### 剖析八种经典排序算法

2016-04-29 23:50:02

#### C#实现所有经典排序算法

2009年03月28日 33KB 下载

#### 实现所有经典排序算法汇总

2009年11月28日 58KB 下载

#### java的几种经典排序算法

2012-07-09 16:28:11

#### 十大经典排序算法总结——Java实现

2016-09-19 12:12:01

#### 经典排序算法，常见的排序算法

2009年01月12日 11MB 下载

#### c#实现所有经典排序算法

2011年11月08日 5KB 下载

#### c语言经典排序算法(8种-含源代码)

2011年12月14日 8KB 下载