标签：之一 OLE int end EDA 桶排序 分区 class 部分 数据
对一序列对象根据某个关键字，按照某种规则进行排序
比较相邻的元素。如果第一个比第二个大，就交换它们两个
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。
从后往前将最小的排到前面
从前往后将最大的拍到后面
/**
* 冒泡排序-数组线性表排序算法
*/
public void bubbleSort(){
if(this.size <= 1){
return ;
}
for(int i = 0;i<this.size;i++){
boolean didSwap = false;
for(int j = 0;j<this.size-i-1;j++){
if(((Comparable<E>)objects[j+1]).compareTo((E)objects[j])<0){
Comparable<E> temp =(Comparable<E>) objects[j+1];
objects[j+1] = objects[j];
objects[j] = temp;
didSwap = true;
}
}
if(!didSwap){
return ;
}
}
}
/**
* 冒泡排序-链式表排序算法
*/
public void bubbleSort(){
if(this.head.next == null||this.head.next.next==null){
return ;
}
//后面已经浮上来的（排好序的）头结点
Node<E> sortedHead = null;
//第一个存储元素的结点
Node<E> first = head.next;
for(Node<E> outCur = head.next;outCur!=null;outCur = outCur.next){
Node<E> cur = first;
for(Node<E> afterCur = first.next;afterCur!=sortedHead;afterCur = afterCur.next,cur = cur.next){
if(cur.elem.compareTo(afterCur.elem)>0){
Node.swapElem(cur, afterCur);
}
}
sortedHead = cur;
}
}
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
初始状态：无序区为\(R[1..n]\)，有序区为空；
第i趟排序\((i=1,2,3…n-1)\)开始时，当前有序区和无序区分别为\(R[1..i-1]\)和\(R(i..n）\)。该趟排序从当前无序区中-选出关键字最小的记录 \(R[k]\)，将它与无序区的第1个记录R交换，使\(R[1..i]\)和\(R[i+1..n)\)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
n-1趟结束，数组有序化了。
（1）数组线性表
public class SelectionSorter<E extends Comparable<E>> implements Sorter<E> {
@Override
public void sort(E[] elemArr){
for(int i = 0;i < elemArr.length;i++){
int minIndex = i;
for(int j = i;j<elemArr.length;j++){
if(elemArr[j].compareTo(elemArr[minIndex])<0){
minIndex = j;
}
}
E temp = elemArr[i];
elemArr[i] = elemArr[minIndex];
elemArr[minIndex] = temp;
}
}
}
（2）链式线性表
/**
* 插入排序
*/
public void selectionSort(){
if(this.head.next==null||this.head.next.next==null){
return ;
}
for(Node<E> outCur = head.next;outCur!=null;outCur = outCur.next){
Node<E> innerCur = outCur;
Node<E> afterInnerCur = innerCur.next;
Node<E> minNode = outCur;
for(innerCur = outCur;afterInnerCur!=null;innerCur = innerCur.next,afterInnerCur = afterInnerCur.next){
if(innerCur.elem.compareTo(minNode.elem)<0){
minNode = innerCur;
}
}
Node.swapElem(outCur,minNode);
}
}
从第一个元素开始，该元素可以认为已经被排序
取出下一个元素，在已经排序的元素序列中从后向前扫描
如果该元素（已排序）大于新元素，将该元素移到下一位置
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
将新元素插入到该位置后
重复步骤2~5
public class InsertSorter<E extends Comparable<E>> implements Sorter<E> {
@Override
public void sort(E[] arr) {
for (int i = 1; i < arr.length; i++) {
for (int j = i;j > 0;--j) {
if (arr[j].compareTo(arr[j - 1]) < 0) {
E temp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = temp;
} else {
break;
}
}
}
}
}
package com.sort;
/**
* @author Ni187
*/
public class ShellSorter<E extends Comparable<E>> implements Sorter<E> {
@Override
public void sort(E[] arr) {
for (int gap = arr.length / 2; gap > 0; gap /= 2){
for(int i=gap; i<arr.length; i++){
for(int j=i-gap; j>=0&&arr[j].compareTo(arr[j+gap])>0; j=j-gap){
E temp = arr[j];
arr[j] = arr[j+gap];
arr[j+gap] = temp;
}
}
}
}
}
把长度为n的输入序列分成两个长度为n/2的子序列
对这两个子序列分别采用归并排序
将两个排序好的子序列合并成一个最终的排序序列
package com.sort;
import java.util.Arrays;
/**
* @author Ni187
*/
public class MergeSorter<E extends Comparable<E>> implements Sorter<E> {
@Override
public void sort(E[] arr) {
Object[] mergedArr = new Object[arr.length];
sort(arr, 0, arr.length-1,mergedArr);
}
public void sort(E[] arr, int left, int right,Object[] mergedArr) {
if (right<=left) {
return;
}
int mid = (left + right) / 2;
sort(arr, left, mid,mergedArr);
sort(arr, mid+1 , right,mergedArr);
merge(arr, left, mid, right,mergedArr);
}
private void merge(E[] arr, int left, int mid, int right,Object[] mergedArr) {
int i = left;
int j = mid + 1;
int index = 0;
while (i <= mid && j <= right) {
if (arr[i].compareTo(arr[j]) <= 0) {
mergedArr[index++] = arr[i++];
} else {
mergedArr[index++] = arr[j++];
}
}
while (i <= mid) {
mergedArr[index++] = arr[i++];
}
while (j <= right) {
mergedArr[index++] = arr[j++];
}
index = 0;
while(left <= right){
arr[left++] = (E)mergedArr[index++];
}
}
}
package com.sort;
import java.util.Random;
/**
* @author Ni187
*/
public class QuickSorter<E extends Comparable<E>> implements Sorter<E> {
@Override
public void sort(E[] arr) {
QuickSort(arr, 0, arr.length-1);
}
public void QuickSort(E[] array, int start, int end) {
if (start > end) {
return ;
}
int smallIndex = partition(array, start, end);
QuickSort(array, start, smallIndex - 1);
QuickSort(array, smallIndex + 1, end);
}
public int partition(E[] array, int left, int right) {
int pivot = (int) (left + Math.random() * (right - left));
E basic = array[pivot];
while(left!=right){
while(left < right && array[right].compareTo(basic)>=0){
right--;
}
while(left < right && array[left].compareTo(basic)<=0){
left++;
}
swap(array, left, right);
}
array[left]=basic;
return left;
}
public void swap(E[] array, int i, int j) {
E temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
标签：之一 OLE int end EDA 桶排序 分区 class 部分 数据
原文地址：https://www.cnblogs.com/nishoushun/p/12600480.html
