1.冒泡排序:
(1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。
(2)外面再套个循环就行。
算法复杂度:O(N2) 不罗嗦,上代码:
//冒泡排序(两两交换,外加一个外循环) public static void bubbleSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=0;i<len-1;i++){ for (j=1;j<len-i;j++){ if (sortData[j-1] > sortData[j]){ swap(sortData,j-1,j); } } } }
2. 选择排序
(1)每次从剩下无序中选择最小的元素,进行交换
算法复杂度:O(N2) 不罗嗦,上代码:
//选择排序(从剩下的选最大的交换) public static void selectionSort(int sortData[]){ int i,j,min,index,temp; int len = sortData.length; for (i=0;i<len;i++){ min = sortData[i]; index = i; for (j=i+1;j<len;j++){ if (sortData[j] < min){ min = sortData[j]; index = j; } } swap(sortData,i,index); } }
3.插入排序:
(1)基本操作就是将一个数据插入到已经排好序的有序数据中:
//插入排序,把大的往后移动 public static void insertSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=1;i<len;i++){ temp = sortData[i]; for (j = i-1;j>=0 && temp < sortData[j];j--){ sortData[j+1] = sortData[j]; } sortData[j+1] = temp; } }
3.希尔排序:
是插入排序的改进版,主要是希尔通过引入增量,加强了插入排序的威力。随着增量的减少,就有序了。
//希尔排序 public static void shellSort(int sortData[]){ int i,j,temp; int len = sortData.length; int gap = len/2; while(gap>=1){ for (i=gap;i<len;i++){ temp = sortData[i]; for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){ sortData[j+gap] = sortData[j]; } sortData[j+gap] = temp; } gap = gap/2; } }
4.堆排序
(1)初始堆 (2)adjust到最小堆或最大堆的格式 (3)排序,根位置和最后一个位置换一下位置,再adjust。
利用最大堆,最小堆这一特性,使得每次从无序的列表中选择最大或者最小的数据。
其基本思想为(大顶堆):
1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆,此堆为初始的无序区;
2)将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];
3)由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。
1)运行时间消耗:构建初始堆 和 重建堆的反复筛选上。
构建堆:
每次从最下层的最右边的非终端节点构建,将他和期孩子节点进行比较,每次最多进行两次比较和交互,因此这个构建时间是N
重建堆(排序):
第i次取堆顶需要logi,那么要去n-1次,所以时间复杂度是nlogn
由于堆排序对原始记录的排序状态并不敏感,因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。
2) 空间复杂度上,它只有一个用来交换的暂存单元,也算是非常的不错。不过由于记录的比较与交换是跳跃式进行,因此堆排序也是一种不稳定的排序方法。
另外,由于初始构建堆所需的比较次数较多,因此,它并不适合待排序序列个数较少的情况。
public static void heapSort(int sortData []){ buildMaxHeap(sortData); for(int i=sortData.length-1;i>=1;i--){ swap(sortData,0,i); maxHeap(sortData,i,0); } } public static void buildMaxHeap(int sortData[]){ int half = sortData.length/2; for(int i=half;i>=0;i--){ maxHeap(sortData,sortData.length,i); } } public static void maxHeap(int sortData[],int heapSize,int index){ int left = 2*index+1; int right = 2*index+2; int largest = index; if (left < heapSize && sortData[left]>sortData[index]){ largest = left; } if(right < heapSize && sortData[right]>sortData[largest]){ largest = right; } if (index != largest){ swap(sortData,index,largest); maxHeap(sortData,heapSize,largest); } }
5. 快速排序:
其实是二分法,一般来说以第一个位置做为分界点,把小的放到这个分界点前面,大的放到后面。递归这两部分。
基本思想:选择一个基准元素,通常是选取第一个或者最后一个元素,通过一趟扫描,将待排序的序列分成两部分,一部分比基准元素小,一部分比基准元素大。此时基准元素就在排好序的正确位置。然后采用相同的方法,递归排序划分左右数据。
算法复杂度:平均和最好都是: nlog(n) 最坏情况(逆序): n2 不稳定
//快速排序 public static void quickSort(int sortData[],int start,int end){ if (start >=end) return; int i=start,j=end,value = sortData[i]; boolean flag = true; while(i!=j){ if (flag){ if (value > sortData[j]){ swap(sortData,i,j); flag=false; }else{ j--; } }else{ if (value<sortData[i]){ swap(sortData,i,j); flag=true; }else{ i++; } } } //printValue(sortData); quickSort(sortData,start,j-1); quickSort(sortData,i+1,end); }
c++
//快排 void qsort(int a[],int low,int high){ if (low >= high) return; int first = low; int last = high; int key = a[first]; while(first<last){ while(first<last && a[last]>=key) --last; a[first] = a[last]; while(first<last && a[first]<=key) ++first; a[last] = a[first]; } a[first] = key; qsort(a,low,first-1); qsort(a,first+1,high); }
6 归并排序 c++
void merge(int array[],int low,int mid,int high){ int i = low; int j = mid+1; int k = 0; int *array2 = new int [high-low+1]; while(i <= mid && j <= high){ if (array[i] < array[j]){ array2[k] = array[i]; i++; k++; }else{ array2[k] = array[j]; j++; k++; } } while(i <= mid){ array2[k] = array[i]; k++; i++; } while(j <= high){ array2[k] = array[j]; k++; j++; } for(k=0,i=low;i<=high;i++,k++){ array[i] = array2[k]; } } void mergeSort(int a[],int low,int high){ if (low<high){ int mid = (low+high)/2; mergeSort(a,low,mid); mergeSort(a,mid+1,high); merge(a,low,mid,high); } } int main(){ int arr [10] = {3,4,2,4,6,2,5,7,0,2}; int len; ARR_LEN(arr,len); mergeSort(arr,0,len-1); for(auto x: arr){ cout << x << " "; } }
所有可运行代码:
//gjs public class sort { public static void printValue(int sortData[]){ for (int i = 0;i<sortData.length;i++){ System.out.print(sortData[i]+" "); } System.out.println(); } public static void swap(int [] data ,int pos1, int pos2){ int temp = data[pos1]; data[pos1] = data[pos2]; data[pos2] = temp; } //冒泡排序(两两交换,外加一个外循环) public static void bubbleSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=0;i<len-1;i++){ for (j=1;j<len-i;j++){ if (sortData[j-1] > sortData[j]){ swap(sortData,j-1,j); } } } } //选择排序(从剩下的选最大的交换) public static void selectionSort(int sortData[]){ int i,j,min,index,temp; int len = sortData.length; for (i=0;i<len;i++){ min = sortData[i]; index = i; for (j=i+1;j<len;j++){ if (sortData[j] < min){ min = sortData[j]; index = j; } } swap(sortData,i,index); } } //插入排序,把大的往后移动 public static void insertSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=1;i<len;i++){ temp = sortData[i]; for (j = i-1;j>=0 && temp < sortData[j];j--){ sortData[j+1] = sortData[j]; } sortData[j+1] = temp; } } //希尔排序 public static void shellSort(int sortData[]){ int i,j,temp; int len = sortData.length; int gap = len/2; while(gap>=1){ for (i=gap;i<len;i++){ temp = sortData[i]; for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){ sortData[j+gap] = sortData[j]; } sortData[j+gap] = temp; } gap = gap/2; } } public static void heapSort(int sortData []){ buildMaxHeap(sortData); for(int i=sortData.length-1;i>=1;i--){ swap(sortData,0,i); maxHeap(sortData,i,0); } } public static void buildMaxHeap(int sortData[]){ int half = sortData.length/2; for(int i=half;i>=0;i--){ maxHeap(sortData,sortData.length,i); } } public static void maxHeap(int sortData[],int heapSize,int index){ int left = 2*index+1; int right = 2*index+2; int largest = index; if (left < heapSize && sortData[left]>sortData[index]){ largest = left; } if(right < heapSize && sortData[right]>sortData[index]){ largest = right; } if (index != largest){ swap(sortData,index,largest); maxHeap(sortData,heapSize,largest); } } //快速排序 public static void quickSort(int sortData[],int start,int end){ if (start >=end) return; int i=start,j=end,value = sortData[i]; boolean flag = true; while(i!=j){ if (flag){ if (value > sortData[j]){ swap(sortData,i,j); flag=false; }else{ j--; } }else{ if (value<sortData[i]){ swap(sortData,i,j); flag=true; }else{ i++; } } } //printValue(sortData); quickSort(sortData,start,j-1); quickSort(sortData,i+1,end); } public static void main(String[] args) { int [] a={2,4,1,5,8,9,43,3,7,8,9,0,3}; printValue(a); //bubbleSort(a); //selectionSort(a); //insertSort(a); //heapSort(a); //shellSort(a); quickSort(a,0,a.length-1); printValue(a); } }