排序
1.插入排序
原理：将原序列视作两个序列：单独由第一个元素组成的有序序列和由其余元素组成的无序序列，依次将无序元素与有序元素（依倒序）比较并插入。
代码：
public class InsertSort {
public void sort(int[] a){
for(int i=1; i<a.length; i++){
if(a[i]<a[i-1]){
int index = i-1;
int temp = a[i];
while(index>=0&&temp<a[index]){
a[index+1] = a[index];
index--;
}
a[index+1] = temp;
}
}
}
}
2.选择排序
原理：从序列中选出最小（最大）值与第一个元素交换次序，再从其余元素中选择最小（最大）值与第二个元素交换次序，依此类推。
代码：
public class SelectionSort {
public void sort(int[] a){
for(int i=0; i<a.length-1; i++){
int min = a[i], index = i;
for(int j=i+1; j<a.length; j++){
if(a[j]<min){
min = a[j];
index = j;
}
}
a[index] = a[i];
a[i] = min;
}
}
}
3.冒泡排序
原理：重复依次比较序列中相邻的无序元素，若次序不符合要求，交换两者次序，每一次遍历减少一个无序元素。
代码：
public class BubbleSort {
public void sort(int[] a){
for(int i=0; i<a.length-1; i++){
for(int j=0; j<a.length-1-i; j++){
if(a[j]>a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
}
}
4.快速排序
原理：选取基准元素（第一个元素），将其余原序列元素依次与基准元素比较，分成小于和大于基准元素的两个序列，再对这两个序列作同样处理。
代码：
public class QuickSort {
public void swap(int[] a, int i, int j){
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
public void sort(int[] a){
sort(a, 0, a.length-1);
}
public void sort(int[] a, int beg, int end){
if(a.length>1){
int pivot = a[beg];
int index_s = beg, index_b = end, count = 0;
for(int i=beg+1; i<=end; i++){
while(a[i]>pivot){
swap(a, i, index_b);
index_b--;
if(index_b-index_s==count){
break;
}
}
if(a[i]<pivot){
swap(a, i, index_s);
index_s++;
}else if(a[i]==pivot){count++;}
if(index_b-index_s==count){
break;
}
}
if(index_s-beg>1){sort(a, beg, index_s-1);}
if(end-index_b>1){sort(a, index_b+1, end);}
}
}
}
5.希尔排序
原理：选择末尾元素为1的递减步长（gap）序列，重复将原系列分成gap个子序列并分别作插入排序处理。
代码：
public class ShellSort {
public void insertsort(int[]a, int gap, int count){
for(int i=gap+count; i<a.length; i+=gap){
if(a[i]<a[i-gap]){
int index = i-gap;
int temp = a[i];
while(index>=count&&temp<a[index]){
a[index+gap] = a[index];
index -= gap;
}
a[index+gap] = temp;
}
}
}
public void sort(int[] a){
int gap = a.length/2;
while(gap>0){
for(int i=0; i<gap; i++){
insertsort(a, gap, i);
}
gap /= 2;
}
}
}
6.堆排序
原理：将序列建立为大顶堆，重复将堆顶元素和无序部分末尾元素交换，恢复大顶特性这两个步骤直至所有元素有序。
代码：
public class HeapSort {
public void adjust(int[] a, int index, int len){
if(2*index+2<len){
if(a[index]<a[2*index+1]||a[index]<a[2*index+2]){
int temp = a[index];
if(a[2*index+1]>a[2*index+2]){
a[index] = a[2*index+1];
a[2*index+1] = temp;
adjust(a, 2*index+1, len);
}else{
a[index] = a[2*index+2];
a[2*index+2] = temp;
adjust(a, 2*index+2, len);
}
}
}else if(2*index+1<len&&a[index]<a[2*index+1]){
int temp = a[index];
a[index] = a[2*index+1];
a[2*index+1] = temp;
adjust(a, 2*index+1, len);
}
}
public void sort(int[] a){
for(int i=(a.length-1)/2; i>=0; i--){
adjust(a, i, a.length);
}
for(int i=a.length-1; i>0; i--){
int temp = a[i];
a[i] = a[0];
a[0] = temp;
adjust(a, 0, i);
}
}
}
7.归并排序
原理：原序列分成若干子序列，先使子序列有序，再合并有序的子序列。
代码：
public class MergeSort {
public void merge(int[] a, int beg1, int end1, int end2){
int[] b = new int[end2-beg1+1];
int index1 = beg1;
int index2 = end1+1;
int index = 0;
while(index1<=end1&&index2<=end2){
if(a[index1]<a[index2]) b[index++] = a[index1++];
else b[index++] = a[index2++];
}
if(index2>end2){
for(int i=0; i<=end1-index1 ; i++) a[end2-i] = a[end1-i];
}
for(int i=0; i<index; i++) a[i+beg1] = b[i];
}
public void sort(int[] a){
int len = 1;
while(len<a.length){
int rem = a.length;
while(rem>len){
int beg1, end1, end2;
beg1 = a.length-rem;
end1 = a.length-rem+len-1;
if(rem>=2*len){
end2 = a.length-rem+2*len-1;
}else{end2 = a.length-1;}
merge(a, beg1, end1, end2);
rem -= 2*len;
}
len *= 2;
}
}
}
主函数代码：
public class Main {
public static void print(String str, int[] a){
System.out.println();
System.out.print(str+":");
for(int i=0; i<a.length; i++){
System.out.print(a[i]+" ");
}
}
public static void main(String[] args) {
int n = (int) (Math.random()*100+1);
int[] arr = new int[n];
int[] a = new int[n];
int[] b = new int[n];
int[] c = new int[n];
int[] d = new int[n];
int[] e = new int[n];
int[] f = new int[n];
int[] g = new int[n];
for(int i=0; i<n; i++){
arr[i] = (int) (Math.random()*100+1);
a[i] = arr[i];
b[i] = arr[i];
c[i] = arr[i];
d[i] = arr[i];
e[i] = arr[i];
f[i] = arr[i];
g[i] = arr[i];
}
System.out.print("序列长度："+n);
print("未排序列", arr);
InsertSort ins = new InsertSort();
ins.sort(a);
print("插入排序", a);
SelectionSort sec = new SelectionSort();
sec.sort(b);
print("选择排序", b);
BubbleSort bub = new BubbleSort();
bub.sort(c);
print("冒泡排序", c);
QuickSort qui = new QuickSort();
qui.sort(d);
print("快速排序", d);
ShellSort she = new ShellSort();
she.sort(e);
print("希尔排序", e);
MergeSort mer = new MergeSort();
mer.sort(f);
print("归并排序", f);
HeapSort hea = new HeapSort();
hea.sort(g);
print(" 堆 排 序 ", g);
}
}
此博文系原创 转载需获取作者许可
