经典排序算法的平均时间复杂度:
O
(
N
2
)
{O(N^2)}
O(N2):冒泡、选择、插入
O
(
N
∗
l
o
g
N
)
{O(N*logN)}
O(N∗logN):归并、快速排序、希尔排序、堆排序
O
(
N
)
{O(N)}
O(N):桶排序
经典排序算法的空间复杂度:
O
(
1
)
{O(1)}
O(1):插入、选择、冒泡、堆排序、希尔排序
O
(
l
o
g
N
)
{O(logN)}
O(logN)~
O
(
N
)
{O(N)}
O(N):快速排序
O
(
N
)
{O(N)}
O(N):归并排序
O
(
M
)
{O(M)}
O(M):桶排序(M是桶的大小)
稳定的排序算法: 冒泡、插入、归并、桶排序
不稳定的排序算法: 快速排序、希尔排序、选择排序、堆排序(可记:快些选队 *^_^*)
一、冒泡排序 BubbleSort
classBubbleSort{publicint[]bubbleSort(int[] A,int n){// write code herefor(int i =1; i < n; i++){for(int j =0; j < n -1; j++){if(A[j]> A[j +1]){int t = A[j];
A[j]= A[j +1];
A[j +1]= t;}}}return A;}publicstaticvoidmain(String[] args){
System.out.println(Arrays.toString(newBubbleSort().bubbleSort(newint[]{1,2,3,5,2,3},6)));}}
二、选择排序 SelectionSort
classSelectionSort{publicint[]selectionSort(int[] A,int n){// write code herefor(int i =0; i < n -1; i++){int min = i;for(int j = i; j < n; j++){if(A[j]< A[min]){
min = j;}}int t = A[min];
A[min]= A[i];
A[i]= t;}return A;}publicstaticvoidmain(String[] args){
System.out.println(Arrays.toString(newSelectionSort().selectionSort(newint[]{1,2,3,5,2,3},6)));}}
三、插入排序 InsertionSort
classInsertionSort{publicint[]insertionSort(int[] A,int n){// write code herefor(int i =1; i < n; i++){int j = i -1;int t = A[i];while(j >=0&& A[j]>= t){
A[j +1]= A[j];
j--;}
A[j +1]= t;// System.out.println(Arrays.toString(A));}return A;}publicstaticvoidmain(String[] args){
System.out.println(Arrays.toString(newInsertionSort().insertionSort(newint[]{1,2,3,5,2,3},6)));}}
classHeapSort{/*
堆排序是一种树形选择排序方法,它的特点是:在排序的过程中,将array[0,...,n-1]看成是一颗完全二叉树的顺序存储结构,利用完全二叉树中双亲节点和孩子结点之间的内在关系,在当前无序区中选择关键字最大(最小)的元素。
1. 若array[0,...,n-1]表示一颗完全二叉树的顺序存储模式,则双亲节点指针和孩子结点指针之间的内在关系如下:
任意一节点指针 i:父节点:i==0 ? null : (i-1)/2
左孩子:2*i + 1
右孩子:2*i + 2
2. 堆的定义:n个关键字序列array[0,...,n-1],当且仅当满足下列要求:(0 <= i <= (n-1)/2)
① array[i] <= array[2*i + 1] 且 array[i] <= array[2*i + 2]; 称为小根堆;
② array[i] >= array[2*i + 1] 且 array[i] >= array[2*i + 2]; 称为大根堆;
3. 建立大根堆:
n个节点的完全二叉树array[0,...,n-1],最后一个节点n-1是第(n-1-1)/2个节点的孩子。对第(n-1-1)/2个节点为根的子树调整,使该子树称为堆。
对于大根堆,调整方法为:若【根节点的关键字】小于【左右子女中关键字较大者】,则交换。
之后向前依次对各节点((n-2)/2 - 1)~ 0为根的子树进行调整,看该节点值是否大于其左右子节点的值,若不是,将左右子节点中较大值与之交换,交换后可能会破坏下一级堆,于是继续采用上述方法构建下一级的堆,直到以该节点为根的子树构成堆为止。
反复利用上述调整堆的方法建堆,直到根节点。
4.堆排序:(大根堆)
①将存放在array[0,...,n-1]中的n个元素建成初始堆;
②将堆顶元素与堆底元素进行交换,则序列的最大值即已放到正确的位置;
③但此时堆被破坏,将堆顶元素向下调整使其继续保持大根堆的性质,再重复第②③步,直到堆中仅剩下一个元素为止。
堆排序算法的性能分析:
空间复杂度:o(1);
时间复杂度:建堆:o(n),每次调整o(log n),故最好、最坏、平均情况下:o(n*logn);
稳定性:不稳定
*/publicint[]heapSort(int[] A,int n){// write code herebuildMaxHeap(A);for(int i = A.length -1; i >=1; i--){int t = A[0];
A[0]= A[i];
A[i]= t;adjustDownToUp(A,0, i);}return A;}privatevoidbuildMaxHeap(int[] A){for(int i =(A.length -2)/2; i >=0; i--){adjustDownToUp(A, i, A.length);}}privatevoidadjustDownToUp(int[] A,int k,int length){int t = A[k];for(int i =2* k +1; i < length; i =2* i +1){if(i < length -1&& A[i]< A[i +1]){
i++;}if(t >= A[i]){break;}
A[k]= A[i];
k = i;}
A[k]= t;}publicstaticvoidmain(String[] args){
System.out.println(Arrays.toString(newHeapSort().heapSort(newint[]{1,2,3,5,2,3},6)));}}
七、希尔排序 ShellSort
classShellSort{publicint[]shellSort(int[] A,int n){// write code herefor(int i = n /2; i >=1; i /=2){insertSort(A, i);}return A;}privatevoidinsertSort(int[] A,int step){for(int i = step; i < A.length; i++){int t = A[i];int j = i - step;while(j >=0&& A[j]>= t){
A[j + step]= A[j];
j -= step;}
j += step;
A[j]= t;}}publicstaticvoidmain(String[] args){
System.out.println(Arrays.toString(newShellSort().shellSort(newint[]{1,2,3,5,2,3},6)));}}
八、桶排序 BucketSort
(1). 计数排序 CountingSort
classCountingSort{publicint[]countingSort(int[] A,int n){// write code hereint max = A[0];for(int i =1; i < n; i++){
max = Math.max(max, A[i]);}int[] c =newint[max +1];
Arrays.fill(c,0);for(int i =0; i < n; i++){
c[A[i]]++;}int cnt =0;for(int i =0; i <= max; i++){while(c[i]>0){
A[cnt++]= i;
c[i]--;}}return A;}publicstaticvoidmain(String[] args){
System.out.println(Arrays.toString(newCountingSort().countingSort(newint[]{1,2,3,5,2,3},6)));}}
(2). 基数排序 RadixSort
classRadixSort{publicint[]radixSort(int[] A,int n){// write code hereint max =0;for(int i =0; i < n; i++){
max = Math.max(max, Integer.toString(A[i]).length());}int[][]r =newint[10][A.length+1];initArray(r);for(int i =0; i < max; i++){sortByBit(r,A, i);initArray(r);}return A;}privatevoidinitArray(int[][] r){for(int i =0; i <10; i++){
r[i][0]=0;for(int j =1; j < r[i].length; j++){
r[i][j]=-1;}}}privatevoidsortByBit(int[][]r,int[]A,int t){//按照第t位,将数组A进行基数排序放入r中,然后再放回A中for(int i =0; i < A.length; i++){int v =getValueAt(A[i], t);int cnt = r[v][0];
r[v][++cnt]= A[i];
r[v][0]= cnt;}int k =0;for(int i =0; i <10; i++){for(int j =1; j <= r[i][0]; j++){
A[k++]= r[i][j];}}}privateintgetValueAt(int value,int t){//得到整数value的第t位(从右数,自0开始)。如356的第1位是5for(int i =0; i < t; i++){
value /=10;}return value %10;}publicstaticvoidmain(String[] args){
System.out.println(Arrays.toString(newRadixSort().radixSort(newint[]{54,35,48,36,27,12,44,44,8,14,26,17,28},13)));}}
一、冒泡排序 BubbleSortclass BubbleSort { public int[] bubbleSort(int[] A, int n) { // write code here for (int i = 1; i &amp;lt; n; i++) { for (int j = 0; j &amp;lt; n - 1; j++) {...