参考文献：
http://www.cnblogs.com/liuling/p/2013-7-24-01.html
http://blog.youkuaiyun.com/hguisu/article/details/7776068
无论是算法还是什么基本知识，长时间没写就忘记了，现在整理下各种简单的算法，方便以后复习下。
插入排序之直接插入排序
思想：将一个数值插入有序数列中，这个数列起始值为sourceData[0]。
直接插入排序的平均时间复杂度为O(n2)。
代码如下：
package com.learn.sort;
import java.util.Random;
public class DInsertSort {
public static void main(String[] args) {
int[] sourceData={54,32,76,12,1,65,34,75};
int[] sourceData2=new int[100];
//随机生成100 个10000以内的数组。
Random r = new Random(10000);
for(int l=0;l<sourceData2.length;l++)
{
sourceData2[l]=r.nextInt(10000)+1;
}
DInsertSortRea(sourceData);
}
public static void DInsertSortRea(int [] sourceData)
{
printArray(sourceData);
long startTime=System.currentTimeMillis();
for(int i=1;i<sourceData.length;i++)
{
int temp=0;
for(int k=i-1;k>=0;k--)
{
if(sourceData[i]<sourceData[k])
{
temp=sourceData[k];
sourceData[k]=sourceData[i];
sourceData[i]=temp;
}
else
{
break;
}
}
}
long endTime=System.currentTimeMillis();
printArray(sourceData);
System.out.println("StartTime:"+startTime+"endTime"+ endTime+"runTime:"+(endTime-startTime));
}
public static void printArray(int [] a)
{
for(int i=0;i<a.length;i++)
{
System.out.print(a[i]+" ");
}
System.out.println();
}
}
运行结果
54 32 76 12 1 65 34 75
32 54 12 1 65 34 75 76
StartTime:1476884696198endTime1476884696198runTime:0插入排序之直接二分法插入排序
基本思想：二分法插入排序的思想和直接插入一样，只是找合适的插入位置的方式不同，这里是按二分法找到合适的位置，可以减少比较的次数，其实思想整体没有什么不同。
public static void DivInsert(int[] a)
{
System.out.println("before sort");
printArray(a);
int tmp=0;
int low=0;
int mid=0;
int high=0;
for(int i=1;i<a.length;i++)
{
low=0;
mid=0;
high=i-1;
tmp=a[i];
while(low<=high)
{
mid=(low+high)/2;
if(tmp<a[mid])
{
high=mid-1;
}
else
{
low=mid+1;
}
}
if(low!=i)
{
for(int j=i-1;j>=low;j--)
{
a[j+1]=a[j];
}
a[low]=tmp;
}
}
System.out.println("after sort:");
printArray(a);
}简单选择排序
思想：对每个子数组进行选择，选择最小的放在最前面或者最大的放在最后面，两者可以同时进行。
下面的是将最小的放在前面。
public static void simpleSelectSort(int[] a)
{
System.out.println("before sort");
printArray(a);
for(int i=0;i<a.length;i++)
{
int min=a[i];
int loc=i;
int tmp=0;
for(int j=i+1;j<a.length;j++)
{
if(min>a[j])
{
min=a[j];
loc=j;
}
}
tmp=a[i];
a[i]=min;
a[loc]=tmp;
}
System.out.println("after sort:");
printArray(a);
}简单选择排序的改进——二元选择排序
简单选择排序，每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素（当前趟最大和最小记录）的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序，最多只需进行[n/2]趟循环即可。具体实现如下：
public static void DoubleSelectSort(int[] a)
{
System.out.println("before sort");
printArray(a);
for(int i=0;i<a.length/2;i++)
{
int min=a[i];
int max=a[a.length-1-i];
int loc=i;
int maxloc=a.length-1-i;
int tmp=0;
int maxtmp=0;
for(int j=i+1;j<=a.length-i-2;j++)
{
if(min>a[j])
{
min=a[j];
loc=j;
}
if(max<a[j])
{
max=a[j];
maxloc=j;
}
}
if(min>a[a.length-1])
{
min=a[a.length-1];
loc=a.length-1;
}
if(max<a[i])
{
max=a[i];
maxloc=i;
}
tmp=a[i];
a[i]=min;
a[loc]=tmp;
maxtmp=a[a.length-1-i];
a[a.length-1-i]=max;
a[maxloc]=maxtmp;
}
System.out.println("after sort:");
printArray(a);
}三、交换排序
一：冒泡排序：
基本思想，从第一个开始，每个和下一个对比，大的放到后面去，小的放在前面，最后最大的就会跑到最后了，最多循环a.length，就会有结果了。
参考问下：
http://www.cnblogs.com/kkun/archive/2011/11/23/2260280.html
代码如下
public static void bubbleSort(int[] a) {
System.out.println("befor sorted: ");
printArray(a);
for(int i=0;i<a.length;i++)
{
for(int j=0;j<a.length-i-1;j++)
{
if(a[j]>a[j+1])
{
int tmp=a[j+1];
a[j+1]=a[j];
a[j]=tmp;
}
}
}
System.out.println("after sorted: ");
printArray(a);
}冒泡排序的改进：
1：双向冒泡，即大的往后面冒泡，就是上面那种，同时，小的往前冒泡，这两个操作同时进行，可以减少循环次数。
这里写代码片二：快速排序：
基本思想：选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。
代码：
public static void quick(int[] a){
if(a.length>0)
{
quickSort(a,0,a.length-1);
}
}
public static void quickSort(int[] a,int low ,int high){
if(low<high)
{
int middle=getMiddle(a, low,high);
quickSort(a,0,middle-1);
quickSort(a,middle+1,high);
}
}
public static int getMiddle(int[] a,int low, int high)
{
int tmp=a[low];
while(low<high)
{
while(low<high &&a[high]>tmp)
{
high--;
}
a[low]=a[high];
while (low<high && a[low]<tmp)
{
low++;
}
a[high]=a[low];
}
a[low]=tmp;
return low;
}运行结果：
54 32 76 12 1 65 34 75
1 12 32 34 54 65 75 76 归并排序
基本思想：1）将数组细分为只有一个值的有序数组，组中，合并有序数组，1合并为2，2合并为4，4合并为8。合并方法：创立中间数组，两个有序数组中比较最小的数，得出最小值依次放在中间数组的中，依次循环。
代码如下：
public static void quick(int[] a){
if(a.length>0)
{
quickSort(a,0,a.length-1);
}
}
public static void quickSort(int[] a,int low ,int high){
if(low<high)
{
int middle=getMiddle(a, low,high);
quickSort(a,0,middle-1);
quickSort(a,middle+1,high);
}
}
public static int getMiddle(int[] a,int low, int high)
{
int tmp=a[low];
while(low<high)
{
while(low<high &&a[high]>tmp)
{
high--;
}
a[low]=a[high];
while (low<high && a[low]<tmp)
{
low++;
}
a[high]=a[low];
}
a[low]=tmp;
return low;
}
public static void mergeSort(int[] a ,int left,int right)
{
if(left<right)
{
int middle=(left+right)/2;
mergeSort(a,left,middle);
mergeSort(a,middle+1,right);
merge(a,left,middle,right);
}
}
public static void merge(int[] a,int left,int middle,int right)
{
int[] tmpArr =new int[a.length];
int mid=middle+1;
int tmp=left;
int third=left;
while (left<=middle&&middle<right)
{
if(a[left]<=a[mid])
{
tmpArr[third++]=a[left++];
}
else
{
tmpArr[third++]=a[mid++];
}
}
while(left<=middle)
{
tmpArr[third++]=a[left++];
}
while(middle<=right)
{
tmpArr[middle++]=a[right++];
}
while (tmp<=right)
{
a[tmp]=tmpArr[tmp++];
}
}运行结果
54 32 76 12 1 65 34 75
1 12 32 34 54 65 75 76 基数排序
基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。
public static void baseSort(int[] array)
{
int max=0;
for(int i=0;i<array.length;i++)
{
if(max<array[i])
{
max=array[i];
}
}
int times=0;
while(max>0)
{
max=max/10;
times++;
}
//建立队列
List<ArrayList> queue=new ArrayList<ArrayList>();
for(int i=0;i<10;i++)
{
ArrayList queue1=new ArrayList();
queue.add(queue1);
}
for(int i=0;i<times;i++)
{
for(int j=0;j<array.length;j++)
{
int x=array[j]%(int)Math.pow(10,i+1)/(int) Math.pow(10,i);
ArrayList queue2=queue.get(x);
queue2.add(array[j]);
queue.set(x,queue2);
}
int count=0;
for(int j=0;j<10;j++)
{
while(queue.get(j).size()>0)
{
ArrayList<Integer> queue3=queue.get(j);
array[count]=queue3.get(0);
queue3.remove(0);
count++;
}
}
}
}希尔排序：
基本思想：
先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2
public static void shellSort(int[] array)
{
int d=array.length;
while(true)
{
d=(d+1)/2;
for(int x=0;x<d;x++)
{
for(int i=x+d;i<array.length;i=i+d)
{
int temp=array[i];
int j;
for(j=i-d;j>=0&&array[j]>temp;j=j-d)
{
array[j+d]=array[j];
}
array[j+d]=temp;
}
}
if(d==1)
{
break;
}
}
}未完待续···
扫一扫
6956
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
