插入排序
1、直接插入排序
public void insertSort(int[] a){
for(int i=0;i<a.length;i++){
int key=a[i];
int pos=i;
while(pos>0&&a[pos-1]>key){
a[pos]=a[pos-1];
pos--;
}
a[pos]=key;
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
直接插入排序(Straight Insertion Sort)是一种最简单的排序方法:将一个记录插入到已排好的有序表中,从而得到一个新的、记录数增1 的有序表。
时间复杂度O(n2),空间复杂度O(1),稳定。
2、希尔排序
public static void shellSort(int[] arrays){
if(arrays == null || arrays.length <= 1){
return;
}
//增量
int incrementNum = arrays.length/2;
while(incrementNum >= 1){
for(int i=0; i < arrays.length; i ++){
//进行插入排序
for(int j=i; j<arrays.length-incrementNum; j=j+incrementNum){
if(arrays[j] > arrays[j+incrementNum]){
int temple = arrays[j];
arrays[j] = arrays[j + incrementNum];
arrays[j+incrementNum] = temple;
}
}
}
//设置新的增量
incrementNum = incrementNum/2;
}
for(int i=0; i < arrays.length; i++){
System.out.print(arrays[i]+" ");
}
}
希尔排序(Shell‘s Sort)又称为“最小增量排序”:先将整个带排记录分割成为若干子序列分别进行直接插入排序,待整个序列中的记录“基本有序”时,再将全体记录进行一次直接插入排序。详细说明:先将要排序的一组数按增量d(d=n/2,n为待排个数)分成若干组,对每组中全部元素进行直接插入排序,然后按d/2增量分组,直至d=1结束。
时间复杂度O(n2),不稳定。
快速排序
3、冒泡排序
public void bubbleSort(int[] a){
int temp=0;
for(int i=0;i<a.length;i++){
for(int j=i;j<a.length;j++){
if(a[i]>a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
}
冒泡排序(Bubble Sort)比较简单就不讲了。
时间复杂度O(n2),稳定。
4、快速排序
public void QuickSort(int[] a,int low,int high){
int dp;
if(low<high){
dp=partition(a,low,high);
QuickSort(a,low,dp-1);
QuickSort(a,dp+1,high);
}
}
public static int partiton(int[] a,int left,int right({
int pivot=a[left];
while(left<right){
while(left<right&&a[right]>=pivot){
right--;
}
if(left<right){
a[left++]=a[right];
}
while(left<right&&a[left<=pivot){
left++;
}
if(left<right){
a[right--]=a[left];
}
}
a[left]=pivot;
return left;
}
快速排序(Quick Sort)是对冒泡排序的一种改进:通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。一趟排序的详细说明:设枢轴记录的关键字为pivotkey,则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录交换,然后从low所指位置起向后搜索,找到第一个关键字大于pivotkey的记录和枢轴记录交换,重复步骤直到low=high。
时间复杂度O(nlogn),空间复杂度O(logn),不稳定。平均性能最好!!!
选择排序
5、简单选择排序
public SelectSort(int[] a){
int min=0,temp=0;
for(int i=0;i<a.length;i++){
min=i;
for(int j=i+1j<a.length;j++){
if(a[j]<a[min])
min=j;
}
if(min!=i){
a[i]<->a[min];
}
}
}
选择排序(Simple Selection Sort)是选择关键字最小的记录作为有序序列的第i个记录。
时间复杂度O(n2),不稳定。
6、堆排序
public void HeapSort(int[] a){
for(int i=0;i<a.length;i++){
createMaxHeap(a,a.length-1-i);
swap(a,0,a.length-1-i);
}
}
public static void createMaxHeap(int[] a,int last){
for(int i=(last-1)/2;i>=0;i--){
int k=i;//保存当前节点
while(a*k+1<=last){//当前节点存在子节点
int big=2*k+1;
if(big<last){//如果右子节点存在
if(a[big]<<a[big+1])
big++;
}
if(a[k]<a[big]){
swap(a,k,big);
k=big;
}else{
break;
}
}
}
}
pubilc static void swap(int[] a,int i,int j){
if(i==j){
return;
}
a[i]<->a[j];
}
堆排序(Heap Sort)每一趟排序的基本操作将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换,然后将新的无序区调整为堆。
时间复杂度O(nlogn),空间复杂度O(1)。
归并排序
7、2路归并排序
public void Sort(int[] a,int low,int high){
int mid=(low+high)/2;
if(low<high){
Sort(a,low,mid);//左边
Sort(a,mid+1,high);//右边
merge(a,low,mid,high);
}
}
public void merge(int[] a,int low,int mid,int high){
int[] temp=new int[high-low+1];
int i=low;
int j=high;
int k=0;
while(i<=mid&&j<=high){
if(a[i]<a[j]){
temp[k++]=a[i++];
}else{
temp[k++]=a[j++];
}
}//while
while(i<mid){
temp[k++]=a[i++];
}
<pre name="code" class="java"> while(j<high){
temp[k++]=a[j++];
}
for(int x=0;x<temp.length;x++){
a[x+low]=temp[x];
}
}
2路-归并排序(Merging Sort)是将两个有序表合并成一个新的有序表。
时间复杂度O(nlogn),空间复杂度O(n),稳定。
计数排序
8、计数排序
public CountSort(int[] a){
int k=a.lenght;
int[] res=new int[k];
int count[]=new int[k];
for(int i=0;i<k;i++){//初始化
count[i]=0;
}
//将数组中的重复的次数
for(int i=0;i<a.length;i++){
count[a[i]]=count[a[i]+1];
}
for(int i=1;i<k;i++){
count[i]=count[i]+count[i-1];
}
//将数组a中的元素按顺序复制到res中
for(int i=a.length-1;i>=0;i--){
res[count[a[i]]-1]=a[i];
count[a[i]]--;
}
}
计数排序不需要俩个数之间的对比呦~