原理参考：
http://sjjp.tjuci.edu.cn/sjjg/DataStructure/DS/web/paixu/paixu8.3.1.1.htm
直接插入算法java实现：
package com.dxy.sort;
public class DirectInsertSort {
public static void main(String[] args) {
int a[] = {5,6,3,2,9,1,4};
sort(a);
}
public static void sort(int a[]) {
int temp = 0;
for(int i=1;i<a.length;i++) {
int j = i-1;
temp = a[i];
for(;j>=0 && a[j]>temp;j--) {
a[j+1] = a[j]; //向后移动一位
}
a[j+1] = temp; //把数插入到a[j] 后面a[j+1]
}
for(int k = 0;k<a.length;k++) {
System.out.println(a[k]);
}
}
}
简单选择排序java实现：
package com.dxy.sort;
public class SelectSort {
public static void main(String[] args) {
int a[] = {5,6,3,2,9,1,4};
sort(a);
}
public static void sort(int a[]) {
int temp = 0;
for(int i = 0;i<a.length-1;i++) {
int minIndex = i;
int min = a[minIndex];
for(int j = i+1;j<=a.length-1;j++) { //为什么j<=a.length-1
if(a[j]<min) {
min = a[j];
minIndex = j;
}
}
if(minIndex != i) {
temp = a[i];
a[i] = a[minIndex];
a[minIndex] = temp;
}
}
for(int k = 0;k<a.length;k++) {
System.out.println(a[k]);
}
}
}
折半插入排序java实现：
package com.dxy.sort;
import java.util.Arrays;
public class HalfFindInsertSort {
public static void main(String args[])
{
int array[]={49,38,65,97,76,13,27};
binaryInsertSort(array,array.length);
System.out.println("------------排序后的结果-------------");
System.out.println(Arrays.toString(array));
}
/**
*
* @param array 要排序的数组
* @param size 数组的大小
*/
public static void binaryInsertSort(int []array,int size)
{
int i,j,temp;
int low,high,mid;
for(i=1;i<size;i++)
{
//将待插入的元素赋给temp，这个元素前面是有序数组，用于插入到有序数组中
temp=array[i];
low=0;
high=i-1;
while(low<=high)
{
//有序数组的中间坐标，此时用于二分查找，减少查找次数
mid = (low+high)/2;
//如果有序序列中的中间元素大于待排序的元素，则有序序列的中间坐标向前搜索，否则向后搜索
if(array[mid]>array[i])
high=mid-1;
else
low = mid + 1;
}
/**
* j首先赋值为要插入值的前一个元素的最后的坐标，也就是有序数组中最后一个元素的坐标
* 然后依次向前扫描有序数组，然后如果满足条件则向后移动数据
*/
for(j=i-1;j>=low;j--)
{
array[j+1]=array[j];
}
//将待排序的元素插入到array数组中
array[low]=temp;
System.out.println(Arrays.toString(array));
}
}
}
堆排序java实现：
import java.util.Arrays;
public class HeapSort {
int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
public HeapSort(){
heapSort(a);
}
public void heapSort(int[] a){
System.out.println("开始排序");
int arrayLength=a.length;
//循环建堆
for(int i=0;i<arrayLength-1;i++){
//建堆
buildMaxHeap(a,arrayLength-1-i);
//交换堆顶和最后一个元素
swap(a,0,arrayLength-1-i);
System.out.println(Arrays.toString(a));
}
}
private void swap(int[] data, int i, int j) {
// TODO Auto-generated method stub
int tmp=data[i];
data[i]=data[j];
data[j]=tmp;
}
//对data数组从0到lastIndex建大顶堆
private void buildMaxHeap(int[] data, int lastIndex) {
// TODO Auto-generated method stub
//从lastIndex处节点（最后一个节点）的父节点开始
for(int i=(lastIndex-1)/2;i>=0;i--){
//k保存正在判断的节点
int k=i;
//如果当前k节点的子节点存在
while(k*2+1<=lastIndex){
//k节点的左子节点的索引
int biggerIndex=2*k+1;
//如果biggerIndex小于lastIndex，即biggerIndex+1代表的k节点的右子节点存在
if(biggerIndex<lastIndex){
//若果右子节点的值较大
if(data[biggerIndex]<data[biggerIndex+1]){
//biggerIndex总是记录较大子节点的索引
biggerIndex++;
}
}
//如果k节点的值小于其较大的子节点的值
if(data[k]<data[biggerIndex]){
//交换他们
swap(data,k,biggerIndex);
//将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
k=biggerIndex;
}else{
break;
}
}
归并排序java实现：
import java.util.Arrays;
public class mergingSort {
int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
public mergingSort(){
sort(a,0,a.length-1);
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
public void sort(int[] data, int left, int right) {
// TODO Auto-generated method stub
if(left<right){
//找出中间索引
int center=(left+right)/2;
//对左边数组进行递归
sort(data,left,center);
//对右边数组进行递归
sort(data,center+1,right);
//合并
merge(data,left,center,right);
}
}
public void merge(int[] data, int left, int center, int right) {
// TODO Auto-generated method stub
int [] tmpArr=new int[data.length];
int mid=center+1;
//third记录中间数组的索引
int third=left;
int tmp=left;
while(left<=center&&mid<=right){
//从两个数组中取出最小的放入中间数组
if(data[left]<=data[mid]){
tmpArr[third++]=data[left++];
}else{
tmpArr[third++]=data[mid++];
}
}
//剩余部分依次放入中间数组
while(mid<=right){
tmpArr[third++]=data[mid++];
}
while(left<=center){
tmpArr[third++]=data[left++];
}
//将中间数组中的内容复制回原数组
while(tmp<=right){
data[tmp]=tmpArr[tmp++];
}
System.out.println(Arrays.toString(data));
}
}
基数排序java实现:
import java.util.ArrayList;
import java.util.List;
public class radixSort {
int a[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,101,56,17,18,23,34,15,35,25,53,51};
public radixSort(){
sort(a);
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
public void sort(int[] array){
//首先确定排序的趟数;
int max=array[0];
for(int i=1;i<array.length;i++){
if(array[i]>max){
max=array[i];
}
}
int time=0;
//判断位数;
while(max>0){
max/=10;
time++;
}
//建立10个队列;
List<ArrayList> queue=new ArrayList<ArrayList>();
for(int i=0;i<10;i++){
ArrayList<Integer> queue1=new ArrayList<Integer>();
queue.add(queue1);
}
//进行time次分配和收集;
for(int i=0;i<time;i++){
//分配数组元素;
for(int j=0;j<array.length;j++){
//得到数字的第time+1位数;
int x=array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i);
ArrayList<Integer> queue2=queue.get(x);
queue2.add(array[j]);
queue.set(x, queue2);
}
int count=0;//元素计数器;
//收集队列元素;
for(int k=0;k<10;k++){
while(queue.get(k).size()>0){
ArrayList<Integer> queue3=queue.get(k);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}
}
希尔排序java实现：
public class shellSort {
public shellSort(){
int a[]={1,54,6,3,78,34,12,45,56,100};
double d1=a.length;
int temp=0;
while(true){
d1= Math.ceil(d1/2);
int d=(int) d1;
for(int x=0;x<d;x++){
for(int i=x+d;i<a.length;i+=d){
int j=i-d;
temp=a[i];
for(;j>=0&&temp<a[j];j-=d){
a[j+d]=a[j];
}
a[j+d]=temp;
}
}
if(d==1)
break;
}
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
