插入排序
1、原理:在有序数组中从后向前扫描找到要插入元素的位置,将元素插入进去。
2、步骤:插入元素和依次和前一个元素进行比较,若比前一个元素小就交换位置,否则结束循环。
3、代码:
package ecut.sort;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import edu.princeton.cs.algs4.StdOut;
/**
*
* 插入排序是将数组中无序数中依次和有序数进行比较,直到插入到正确的位置。
* 需要n-1趟完成排序,比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,最好是n-1次比较。
* 交换次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,最好是0次交换。时间复杂度是O(n^2)。
*/
public class InsertionSort {
private static Scanner sc;
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
int N = a.length;
for (int i = 1; i < N; i++) {
for (int j = i - 1; j >= 0 && less(a[j + 1], a[j]); j--) {
exch(a, j + 1, j);
}
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
}
@SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
@SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
}
@SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a);
}
}
排序方法等价于:
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
int N = a.length;
for (int i = 1; i < N; i++) {
//用k记录当前的位置
int k = i;
for (int j = i - 1; j >= 0; j--) {
if (less(a[k], a[j])) {
exch(a, k, j);//k=i,j=i-1 ===> k=j+1
//交换后要让k重新指向插入元素的位置
k--;
}else{
break;
}
}
}
}
插入排序是将数组中无序数中依次和有序数进行比较,直到插入到正确的位置。需要n-1趟完成排序,比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,最好是n-1次比较。交换次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,最好是0次交换。时间复杂度是O(n^2)。
选择排序
1、原理:依次从数组中选出最小的放入到对应位置。
2、步骤:找出数组中的最小值,和对应位置的元素进行交换,最小的和a[0]交换,其次小的和a[1]交换,以此类推。
3、代码:
package ecut.sort;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import edu.princeton.cs.algs4.StdOut;
/**
*
* 选择排序是依次选择数组中无序数中最小的和对应的数交换位置,最小的数和a[0]交换,第二小的和a[1]交换,以此类推。
* 需要n-1趟完成排序,比较次数是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,n-1次交换,时间复杂度是O(n^2)
*
*/
public class SelectionSort {
private static Scanner sc;
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
int N = a.length;
for (int i = 0; i < N - 1; i++) {
int min = i;
for (int j = i + 1; j < N; j++) {
if (less(a[j], a[min])) {
min = j;
}
}
exch(a, i, min);
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
}
@SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
@SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
}
@SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a);
}
}
需要n-1趟完成排序,比较次数是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,n-1次交换,时间复杂度是O(n^2)
归并排序
1、原理:将两个有序数组合并成一个新的有序数组。
2、步骤:对数组进行折半,分别对两边数组进行归并排序,先讲需要排序的数组拷贝到一个新数组中,然后比较mid+1和low所对应的值,将较小的数放入到拷贝数组中,以此类推。
3、代码:
package ecut.sort;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import edu.princeton.cs.algs4.StdOut;
/**
*
* 归并排序是将两个有序的数组合并到一个数组中。
* 数组长度为n的数组,比较次数所形成的二叉树有n层,总节点数是N=2^n-1,n=lgN+1 ~ lgN,比较次数最坏是n*2^n次即NlgN,最好是1/2 NlgN次比较。
* 时间复杂度是O(n log n)
*/
public class MergeSort {
private static Scanner sc;
@SuppressWarnings("rawtypes")
private static Comparable[] aux;
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
aux = new Comparable[a.length];
sort(a,0,a.length-1);
}
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a,int lo,int hi){
if(hi<=lo) return;
int mid =lo+ (hi-lo)/2;
sort(a,lo,mid);
sort(a,mid+1,hi);
merge(a,lo,mid,hi);
}
@SuppressWarnings("rawtypes")
public static void merge(Comparable[] a,int lo, int mid,int hi){
int i=lo;
int j=mid+1;
for(int k=lo;k<=hi;k++){
aux[k]=a[k];
}
for (int k = lo; k <= hi; k++) {
if (i > mid)
a[k] = aux[j++];
else if(j>hi)
a[k] = aux[i++];
else if(less(aux[j],aux[i]))
a[k]=aux[j++];
else
a[k]=aux[i++];
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
}
@SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
}
@SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a);
}
}
归并排序是将两个有序的数组合并到一个数组中。数组长度为n的数组,比较次数所形成的二叉树有n层,总节点数是N=2^n-1,n=lgN+1 ~ lgN,比较次数最坏是n*2^n次即NlgN,最好是1/2 NlgN次比较。 时间复杂度是O(n log n)。
冒泡排序
1、原理:依次比较相邻两个数的大小,最大的i数沉到zu
2、步骤:每趟排序中依次比较相邻两个数的大小,a[0]和a[1]比较,a[1]和a[2]比较,以此类推,直至结束,然后重复执行,直到所有的书有序。
3、代码:
package ecut.sort;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import edu.princeton.cs.algs4.StdOut;
/**
*
* 冒泡排序是将数组依次比较相邻的两个数,将小数放在前面,大数放在后面。
* 需要n-1趟完成排序,比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,时间复杂度是O(n^2)。
*/
public class BubbleSort {
private static Scanner sc;
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
for(int i=0; i<a.length-1;i++){
for(int j=0; j<a.length-i-1;j++){
if(less(a[j+1],a[j])){
exch(a,j+1,j);
}
}
}
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
}
@SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
@SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
}
@SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a);
}
}
冒泡排序是将数组依次比较相邻的两个数,将小数放在前面,大数放在后面。需要n-1趟完成排序,比较次数最坏是1+2.....+(n-1)即n(n-1)/2 ~ n^2/2次,时间复杂度是O(n^2)。
快速排序
1、原理:找到一个目标元素,把比目标元素小的数放在目标元素的左侧,比目标元素大的数放在目标元素的右侧。
2、步骤:将 i 赋值为需要排序元素的初始位置,将 j 指向数组的末尾位置+1,然后让 i 依次后移,j 依次前移,若 j 所指向位置的元素比目标元素小就退出while循环,若 i 所指向位置的元素比目标元素大就退出while循环,然后交换两个元素。分别对数组的左半边和右半边都进行排序。
3、代码:
package ecut.sort;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
/**
*
* 快速排序是将数组切分使左侧小于a[j],右侧大于a[j]。
* 时间复杂度是O(n log n)
*
*/
public class QuickSort {
private static Scanner sc;
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a) {
StdRandom.shuffle(a);//清楚对输入的依赖
sort(a,0,a.length-1);
}
@SuppressWarnings("rawtypes")
public static void sort(Comparable[] a,int lo,int hi){
if(hi<=lo) return;
int j=partition(a,lo,hi);
sort(a,lo,j-1);
sort(a,j+1,hi);
}
@SuppressWarnings("rawtypes")
public static int partition(Comparable[] a,int lo,int hi){
Comparable v = a[0];
int i = lo;
int j = hi+1;
while(true){
while(less(a[++i],v)){
if(i==hi){
break;
}
}
while(less(v,a[--j])){
if(j==lo){
break;
}
}
if(i>=j){
break;
}
exch(a,i,j);
}
exch(a,lo,j);
return j;
}
@SuppressWarnings("rawtypes")
public static void exch(Comparable[] a, int i, int j) {
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
public static boolean less(Comparable v, Comparable w) {
// v.compareTo(w):v<w 返回负整数 v=w 返回0 v>w 返回正整数
return v.compareTo(w) < 0;
}
@SuppressWarnings("rawtypes")
public static void show(Comparable[] a) {
for (int i = 0; i < a.length; i++) {
StdOut.print(a[i] + " ");
}
StdOut.println();
}
@SuppressWarnings("rawtypes")
public static boolean isSorted(Comparable[] a) {
for (int i = 1; i < a.length; i++) {
if (less(a[i], a[i - 1])) {
return false;
}
}
return true;
}
public static void main(String[] args) {
sc = new Scanner(System.in);
String[] a = null;
List<String> list = new ArrayList<String>();
while(sc.hasNextLine()){
list.add(sc.nextLine());
}
a=list.toArray(new String[0]);
sort(a);
assert isSorted(a);
show(a);
}
}
快速排序的时间复杂度是O(n log n)。
转载请于明显处标明出处
https://www.cnblogs.com/AmyZheng/p/9502759.html
推荐博客链接