【数据结构】8类基本排序算法
1. 排序算法的分类：
2.各类算法总结：
3.直接插入排序：
算法实现：
public int[] insertSort(int[] data){
for(int i = 1; i < data.length; i++){
//判断无序区的第一个元素是否小于有序区的最后一个元素（即有序区的最大元素）
if(data[i] < data[i - 1]){
int temp = data[i];
int j = 0;
//将有序区的元素向后移动，为待插入的元素留出位置
for(j = i - 1; j >= 0 && temp < data[j]; j--){
data[j + 1] = data[j];
}
data[j + 1] = temp; //将data[i]插入到有序区的位置上
}
}
return data;
}
4.希尔排序：
算法实现：
public int[] shellSort(int[] data){
int i, j, temp, d; //d为当前增量
int increment = data.length / 3; //增量的起始值取总长度的1/3
for(int m = increment; m >= 1; m--){
d = m;
for(i = d; i < data.length; i++){
//将data[d + 1..n]分别插入各组当前的有序区
if(data[i] < data[i - d]){
temp = data[i];
j = i;
do{ //查找data[i]的插入位置
data[j] = data[j - d]; //后移记录
j = j -d; //查找前一条记录
if(j - d <0){
break;
}
}while (j > 0 && temp < data[j - d]);
data[j] = temp; //插入data[i]到正确的位置上
}
}
}
return data;
}
5.选择排序：
算法实现：
public int[] selectSort(int[] data){
int k; //k记下目前找到的最小关键字所在的位置
int temp;
for(int i = 0; i < data.length; i++){
k = i;
for(int j = i + 1; j < data.length; j++){
if(data[j] < data[k]){
k = j;
}
}
if(k != i){ //交换
temp = data[i];
data[i] = data[k];
data[k] = temp;
}
}
return data;
}
6.堆排序：
算法实现：
//将完全二叉树构建成最大堆
public void createHeap(int[] data, int low, int high){
if((low < high) && (high < data.length)){
int j = 0;
int k = 0;
int tmp = 0;
for(int i = high / 2; i >= low; --i){
tmp = data[i];
k = i;
j = 2 * k + 1;
while(j <= high){
if((j < high) && (j + 1 <= high) && (data[i] < data[j + 1])){
++j;
}
if(tmp < data[j]){
data[k] = data[j];
k = j;
j = 2 * k + 1;
}else {
break;
}
}
data[k] = tmp;
}
}
}
//在实现构建堆算法的基础上，实现堆排序算法
public int[] heapSort(int[] data){
int tmp = 0;
createHeap(data, 0, data.length - 1);
for(int i = data.length - 1; i > 0; --i){
tmp = data[0];
data[0] = data[i];
data[i] = tmp;
createHeap(data, 0, i -1);
}
return data;
}
7.冒泡排序：
算法实现：
public int[] bubbleSort(int[] data){
boolean exchange = false; //交换标志
int tmp;
int n = data.length;
for(int i = 1; i < n; i++){ //最多做n-1趟排序
for(int j = 0; j < n -i; j++){
//对当前无序区data[0..n-i]自下而上扫描
if(data[j] > data[j + 1]){
tmp = data[j];
data[j] = data[j + 1];
data[j + 1] = tmp;
exchange = true;
}
if(!exchange){
break;
}
}
}
return data;
}
8.快速排序：
算法实现：
public int[] quickSort(int[] data){
return quickSort(data, 0, data.length - 1);
}
public int[] quickSort(int[] data, int low, int high){
if(low > high){
return null;
}
int pivot = data[low]; //临时变量Pivot
int i = low + 1;
int j = high;
int temp;
while (i < j){
while ((i < j) && (pivot >= data[i])){
++i;
}
while ((j >= i) && (pivot <= data[j])){
--j;
}
if(i < j){
temp = data[i];
data[i] = data[j];
data[j] = temp;
}
}
if(low < j){
temp = data[low];
data[low] = data[j];
data[j] = temp;
}
quickSort(data, low, j -1);
quickSort(data, j + 1, high);
return data;
}
9.归并排序：
算法实现：
public int[] mergeSort(int[] data){ //归并增量
int k = 1;
while (k < data.length){
merge(data, k);
k *= 2;
}
return data;
}
public void merge(int[] data, int len) {
int m = 0; //临时顺序表的起始位置
int l1 = 0; //第1个有序表的起始位置
int h1; //第1个有序表的结束位置
int l2; //第2个有序表的起始位置
int h2; //第2个有序表的结束位置
int i = 0;
int j = 0;
//临时表,用于临时将两个有序表合并为一个有序表
int[] tmp = new int[data.length];
//归并处理
while (l1 + len < data.length){
l2 = l1 + len; //第2个有序表的起始位置
h1 = l2 - 1; //第1个有序表的结束位置
//第2个有序表的结束位置
h2 = (l2 + len -1 < data.length) ? l2 + len -1 : data.length - 1;
j = l2;
i = l1;
//两个有序表中的记录没有排序
while ((i <= h1) && (j <= h2)){
//第1个有序表记录的关键码小于第2个有序表记录的关键码
if(data[i] <= data[j]){
tmp[m++] = data[i++];
}else {
//第2个有序表记录的关键码小于第1个有序表记录的关键码
tmp[m++] = data[j++];
}
}
//第1个有序表中还有记录没有排序
while (i <= h1){
tmp[m++] = data[i++];
}
//第2个有序表中还有记录没有排序
while (j <= h2){
tmp[m++] = data[j++];
}
l1 = h2 + 1;
}
i = l1;
//原顺序表中还有记录没有排序
while (i < data.length){
tmp[m++] = data[i++];
}
//临时顺序表的记录复制到原顺序表，使原顺序表中的记录有序
for(i = 0; i < data.length; i++){
data[i] = tmp[i];
}
}
10.基数排序：
算法实现：
static class RadixNode{
public int data; //数据域
public RadixNode next; //引用域
}
public int[] radixSort(int[] data){
int k, l, power;
RadixNode p, q;
RadixNode[] head = new RadixNode[10];
power = 1;
//首先确定排序的趟数
int max = data[0];
for(int i = 1; i < data.length; i++){
if(data[i] > max){
max = data[i];
}
}
int d = 0; //关键码的位数
while (max > 0){
max /= 10;
d++;
}
//进行d次分配和收集
for(int i = 0; i < d; i++){
if(i == 0){
power = 1;
}else {
power = power * 10;
}
for(int j = 0; j < 10; j++){
head[j] = new RadixNode();
}
//分配数组元素
for(int j = 0; j < data.length; j++){
k = data[j] / power - (data[j] / (power * 10)) * 10;
q = new RadixNode();
q.data = data[j];
q.next = null;
p = head[k].next;
if(p == null){
head[k].next = q;
}else {
while (p.next != null){
p = p.next;
}
p.next = q;
}
}
//搜集链表元素
l = 0;
for(int j = 0; j < 10; j++){
p = head[j].next;
while (p != null){
data[l] = p.data;
l++;
p = p.next;
}
}
}
return data;
}
参考书目：数据结构（java语言版）