1.冒泡排序
排序原理：
- 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
- 对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大
值。
代码实现
方法1
public class BobbleSort {
public static void main(String[] args) {
int[] array={3,17,14,9,2,39};
int temp=0;
//外循环是为了获取每次比较次数，比较次数是从大到小
for (int i=array.length-1;i>0;i--){
//内层循环进行比较
for (int j=0;j<i;j++){
if (array[j]>array[j+1]){
//前值大于后值，调换位置
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
for (int i=0;i<array.length;i++){
System.out.println(array[i]);
}
}
}
方法2
public class BobbleSort2 {
public static void main(String[] args) {
int[] array={3,17,14,9,2,39};
int temp=0;
for (int i = 0; i <array.length-1 ; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j+1]) {
temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
}
时间复杂度O(N2)
*2.选择排序
排序原理：
1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
2.交换第一个索引处和最小值所在的索引处的值
代码实现
public class SelectSort {
public static void main(String[] args) {
int[] array={3,17,14,9,2,39};
int temp=0;
//i最多只需要循环到结尾数字-1的位置
for (int i=0;i<array.length-1;i++){
//令此时的i为最小值
int min=i;
//i与其后的j比较
for (int j=i+1;j<array.length;j++){
//若j位置数小于min处，令j处为新的最小值处，以此循环找到最小值位置
if(array[min]>array[j]){
min=j;
}
}
//找到最小值位置后，交换i与此处元素位置
temp=array[i];
array[i]=array[min];
array[min]=temp;
}
for (int i=0;i<array.length;i++){
System.out.println(array[i]);
}
}
}
时间复杂度O(N2)
3.插入排序
排序原理：
1.把所有的元素分为两组，已经排序的和未排序的；
2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；
代码实现
public class InsertSort {
public static void main(String[] args) {
int[] array = {3, 17, 14, 9, 2, 39};
int temp = 0;
for (int i=1;i<array.length;i++){
//令0位置元素是有序的，则从其后位置不断往前插入
for (int j=i;j>0;j--){
//若待插入位置大于目前位置数，则交换位置
if (array[j]<array[j-1]){
temp=array[j];
array[j]=array[j-1];
array[j-1]=temp;
}else {
//若待插入位置小于目前位置数，则不做操作
break;
}
}
}
for (int i=0;i<array.length;i++){
System.out.println(array[i]);
}
}
}
时间复杂度O(N2)
4.希尔排序
排序原理：
1.选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
2.对分好组的每一组数据完成插入排序；
3.减小增长量，最小减为1，重复第二步操作。
增长量h的确定：增长量h的值每一固定的规则，我们这里采用以下规则：
int h=1
while(h<5){
h=2h+1；//3,7
}
//循环结束后我们就可以确定h的最大值；
h的减小规则为：
h=h/2
代码实现
public class ShellSort {
public static void main(String[] args) {
int[] a = {3, 17, 14, 9, 2, 39};
int temp = 0;
int n=a.length;
//确定增长量h的最大值
int h=1;
while (h<n/2){
h=h*2+1;
}
while (h>=1){
//找到待插入的元素
for (int i=h;i<n;i++){
//a[i]就是待插入的元素
// 把a[i]插入到a[i-h],a[i-2h],a[i-3h]...序列中
for (int j=i;j>=h;j-=h){
//a[j]就是待插入元素，依次和a[j-h],a[j-2h],a[j-3h]进行比较，如果a[j]小，那么 交换位置，如果不小于，a[j]大，则插入完成。
if (a[j-h]>a[j]){
temp=a[j];
a[j]=a[j-h];
a[j-h]=temp;
}else {
break;
}
}
}
h/=2;
}
for (int i=0;i<n;i++){
System.out.println(a[i]);
}
}
}
时间复杂度小于O(N2)
5.归并排序
在了解归并排序前先了解下分治算法：
分治法是一种很重要的算法。字面上的解释是“分而治之”，就是把一个复杂的问题分成两个或更多的相同或 相似的子问题，再把子问题分成更小的子问题……
分治法在每一层递归上都有三个步骤：
分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
合并：将各个子问题的解合并为原问题的解。
分治算法有个经典的汉诺塔问题
汉诺塔的传说
汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金 刚石柱子，在一根柱子上从下往上按照大小顺序摞着 64 片黄金圆盘。大梵天命令婆罗门把圆盘从下面开始按大小 顺序重新摆放在另一根柱子上。并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
汉诺塔游戏的演示和思路分析:
1.如果是有一个盘， A->C 如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的盘 2. 上面的盘
2.先把最上面的盘 A->B
3.把最下边的盘 A->C
4.把 B 塔的所有盘 从 B->C
代码实现
public class 分治算法 {
/*
分治算法的基本步骤
分治法在每一层递归上都有三个步骤：
分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题
解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题
合并：将各个子问题的解合并为原问题的解。
分治算法最佳实践-汉诺塔
汉诺塔游戏的演示和思路分析:
如果是有一个盘， A->C
如果我们有 n >= 2 情况，我们总是可以看做是两个盘 1.最下边的盘 2. 上面的盘
先把 最上面的盘 A->B
把最下边的盘 A->C
把B塔的所有盘 从 B->C
*/
public static void main(String[] args) {
hanoiTower(10,'A','B','C');
}
public static void hanoiTower(int num,char a,char b,char c){
if(num==1){
System.out.println("第1个盘从"+a+"->"+c);
}else{
//如果我们有 n >= 2 情况，我们总是可以看做是两个盘
// 1.最下边的一个盘 2. 上面的所有盘
//1.先把最上面的所有盘A->B,移动过程中使用C
hanoiTower(num-1,a,c,b);
//2. 把最下边的盘 A->C
System.out.println("第" + num + "个盘从 " + a + "->" + c);
//3. 把B塔的所有盘 从 B->C , 移动过程使用到 a塔
hanoiTower(num-1,b,a,c);
}
}
}
归并排序原理：
1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是
1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3.不断的重复步骤2，直到最终只有一个组为止。
public class MargeSort {
//归并所需要的辅助数组
private static Comparable[] assist;
/* 对数组a中的元素进行排序 */
private static void sort(Comparable[]a){
assist=new Comparable[a.length];
int lo=0;
int hi=a.length-1;
sort(a,lo,hi);
}
/*对数组a中从lo到hi的元素进行排序 */
private static void sort(Comparable[]a,int lo,int hi){
if (hi<=lo){
return;
}
int mid=lo+(hi-lo)/2;
//对lo到mid之间的元素进行排序；
sort(a,lo,mid);
//对mid+1到hi之间的元素进行排序；
sort(a,mid+1,hi);
//对lo到mid这组数据和mid到hi这组数据进行归并
merge(a,lo,mid,hi);
}
/*对数组中，从lo到mid为一组，从mid+1到hi为一组，对这两组数据进行归并 */
private static void merge(Comparable[]a,int lo,int mid,int hi){
//lo到mid这组数据和mid+1到hi这组数据归并到辅助数组assist对应的索引处
int i = lo;//定义一个指针，指向assist数组中开始填充数据的索引
int p1 = lo;//定义一个指针，指向第一组数据的第一个元素
int p2 = mid + 1;//定义一个指针，指向第二组数据的第一个元素
//比较左边小组和右边小组中的元素大小，哪个小，就把哪个数据填充到assist数组中
while (p1 <= mid && p2 <= hi) {
if (less(a[p1], a[p2])) {
assist[i++] = a[p1++];
} else {
assist[i++] = a[p2++];
}
}
//上面的循环结束后，如果退出循环的条件是p1<=mid，则证明左边小组中的数据已经归并完毕，如果退 出循环的条件是p2<=hi,则证明右边小组的数据已经填充完毕；
//所以需要把未填充完毕的数据继续填充到assist中,//下面两个循环，只会执行其中的一个
while(p1<=mid){
assist[i++]=a[p1++];
}
while(p2<=hi){
assist[i++]=a[p2++];
}
//到现在为止，assist数组中，从lo到hi的元素是有序的，再把数据拷贝到a数组中对应的索引处
for (int index=lo;index<=hi;index++){
a[index]=assist[index];
}
}
//自定义比较规则
public static boolean greater(Comparable v,Comparable w){
return v.compareTo(w)>0;
}
/*数组元素i和j交换位置 */
public static void exch(Comparable[]a,int i,int j){
Comparable t=a[i];
a[i]=a[j];
a[j]=t;
}
}
//测试代码 public class Test {
public static void main(String[] args) throws Exception {
Integer[] arr = {3, 17, 14, 9, 2, 39};
Merge.sort(arr);
System.out.println(Arrays.toString(arr));
}
时间复杂度O(nlogn）
6.快速排序
排序原理：
1.首先设定一个分界值，通过该分界值将数组分成左右两部分；
2.将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
切分原理：
把一个数组切分成两个子数组的基本思想：
1.找一个基准值，用两个指针分别指向数组的头部和尾部；
2.先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置；
3.再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置；
4.交换当前左边指针位置和右边指针位置的元素；
5.重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。
public class QuickSort {
public static void sort(Comparable[] a){
int lo=0;
int hi=a.length-1;
sort(a,lo,hi);
}
public static void sort(Comparable[] a,int lo,int hi){
if (hi<=lo){
return;
}
//对a数组中，从lo到hi的元素进行切分
int partation=partation(a,lo,hi);
//对左边分组中的元素进行排序
sort(a,lo,partation-1);
//对右边分组中的元素进行排序
sort(a,partation+1,hi);
}
public static int partation(Comparable[] a,int lo,int hi){
//把最左边的元素当做基准值
Comparable key=a[lo];
//定义一个左侧指针，初始指向最左边的元素
int left=lo;
//定义一个右侧指针，初始指向左右侧的元素下一个位置
int right=hi+1;
//进行切分
while (true){
//先从右往左扫描，找到一个比基准值小的元素
while(less(key, a[--right])){//循环停止，证明找到了一个比基准值小的元素
if (right==lo){
//已经扫描到最左边了，无需继续扫描
break;
}
}
//再从左往右扫描，找一个比基准值大的元素
while (less(a[++left],key)){//再从左往右扫描，找一个比基准值大的元素
if (left==hi) {
//已经扫描到了最右边了，无需继续扫描
break;
}
}
if (left>=right){
//扫描完了所有元素，结束循环
break;
}else {
//交换left和right索引处的元素
exch(a,left,right);
}
}
//交换最后rigth索引处和基准值所在的索引处的值
exch(a,lo,right);
//right就是切分的界限
return right;
}
public static void exch(Comparable[] a,int i,int j){
Comparable t;
t=a[i];
a[i]=a[j];
a[j]=t;
}
public static boolean less(Comparable v,Comparable w){
return v.compareTo(w)<0;
}
}
public class Test {
public static void main(String[] args) throws Exception {
Integer[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 8};
Quick.sort(arr);
System.out.println(Arrays.toString(arr));
}
}
时间复杂度O(nlogn)
扫一扫
3789
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
