一、插入排序
——直接插入排序
private void insertSort(int[] data) {
for(int i=1;i<data.length;i++){
int tmp=data[i];
int j=i-1;
for(;j>=0&&data[j]>tmp;j--){//将大于tmp的值整体往后移一个单位
data[j+1]=data[j];
}
data[j+1]=tmp;
}
System.out.println(Arrays.toString(data));
}
——希尔排序
public void shellSort(int[] data){
double d1=data.length;
while (true){
d1= (int) Math.ceil(d1/2);
int d= (int) d1;
for(int i=0;i<d;i++){
for(int j = i+d; j<data.length; j+=d){
int tmp=data[j];
int k=j-d;
for(;k>=0 && data[k]>tmp;k-=d){
data[k+d]=data[k];
}
data[k+d]=tmp;
}
}
if(d==1){
break;
}
}
System.out.println(Arrays.toString(data));
}
二、选择排序
——简单选择排序
private void selectSort(int[] data) {
for(int i=0;i<data.length-1;i++){
int tmp=data[i];//假设第i个最小,记录其值
int position=i;//假设第i个最小,记录其下标
for(int j=i+1;j<data.length;j++){
if(data[j]<tmp){
tmp=data[j];//更新最小的数,并记录下标和值
position=j;
}
}
data[position]=data[i];//position处放原来在i处的数
data[i]=tmp;//第i个位置放最小的数
}
System.out.println(Arrays.toString(data));
}
——堆排序
public void heapSort(int[] a){
int lastIndex=a.length-1;
System.out.println("开始构建堆");
for(int i=(lastIndex-1)/2;i>=0;i--){
adjustDown(a,i,a.length-1);
}
System.out.println("初始最大堆"+Arrays.toString(a));
//将堆顶元素与最后一个元素进行交换,从堆顶开始向下调整
for(int i=0;i<a.length-1;i++){
swap(a,0,a.length-1-i);
System.out.println("第"+(i+1)+"次交换"+Arrays.toString(a));
adjustDown(a,0,a.length-2-i);
System.out.println("调整后:"+Arrays.toString(a));
}
}
//the second method,不需要交换,只做移动和标记
private void adjustDown(int[] a, int start, int end) {
int tmp=a[start];
while (2*start+1<=end){
int biggerIndex=2*start+1;
if(2*start+2<=end){
if(a[biggerIndex]<a[biggerIndex+1]){
biggerIndex++;
}
}
if(tmp>=a[biggerIndex])
break;
else {
a[start]=a[biggerIndex];
start=biggerIndex;
}
}
a[start]=tmp;
}
三、交换排序
——冒泡排序
public void bubbleSort(int[] data){
for(int i=0;i<data.length-1;i++){
for(int j=0;j<data.length-1-i;j++){
if(data[j]>data[j+1]){
int tmp=data[j];
data[j]=data[j+1];
data[j+1]=tmp;
}
}
}
}
——快速排序
public void quickSort(int[] data,int left,int right){
if(left<right){
int pivotpos=partition(data,left,right);
quickSort(data,left,pivotpos-1);
quickSort(data,pivotpos+1,right);
}
}
private int partition(int[] data, int low, int high) {
int pivot=data[low]; //待排序的第一个元素作为基准元素
while (low<high){
while (low<high&&data[high]>=pivot){
high--;//从右往左扫描,找到第一个比基准元素小的元素
}
data[low]=data[high];//找到这种元素arr[high]后与arr[low]交换
while (low<high&&data[low]<=pivot){
low++;//从左往右扫描,找到第一个比基准元素大的元素
}
data[high]=data[low];//找到这种元素arr[low]后,与arr[high]交换
}
data[low]=pivot;//基准元素归位,low/high都一样
return low;
}
四、归并排序
public void mergeSort(int[] data,int low,int high){
if(low<high){
int mid=(low+high)/2;
mergeSort(data,low,mid);
mergeSort(data,mid+1,high);
merge(data,low,mid,high);
}
}
private void merge(int[] data, int low, int mid, int high) {
int[] datac= Arrays.copyOf(data,data.length);
int k=low;
int i=low;
int j=mid+1;
while (i<=mid&&j<=high){
if(datac[i]<=datac[j]){
data[k++]=datac[i++];
}else {
data[k++]=datac[j++];
}
}
while (i<=mid){
data[k++]=datac[i++];
}
while (j<=high){
data[k++]=datac[j++];
}
}