2023.4.11

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量307 收藏
点赞数
分类专栏： 打卡区 文章标签： java 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SCR1209/article/details/130094444
版权

文章目录

实现key前面的数都小于等key，key后面的数都大于等于key

1：前后指针法：

在这里插入图片描述

	public static void Sort(int[] array,int L,int R，int key) {
        int left = L;
        int right = R;
        //确保key左边的都小于等于key，右边的都大于等于key
        while(left < right) {
            while (left < right && array[right] >= key) { 
                // 注意这里的等号要加 否则陷入死循环
                right--;
            }
            //出循环之后right所指的数一定小于key
            while(left < right && array[left] <= key) {
                left++;
            }
            //出循环之后left所指的数一定大于key
            swap(array,left,right);
        }
        //这样left后面的数一定大于等于key，left前面的数一定小于等于key
    }

2：挖坑法

在这里插入图片描述

	public static void sort(int[] array,int index) { // index是你的key的下标
        swap(array,0,index); // 把key的值尽量往前方，重点。
        int key = array[0];
        int right = array.length-1;
        int left = 0;
        while(left < right) {
            while(left < right && array[right] >= key) {
                /**
                这里加left < right 这个限制条件而不是right >= 0,
                是因为如果出现right-- ,right小于left时候，此时还不会执行最外层while判断
                ，然后进行swap交换，这是错误的。
                而且left < right这个条件比right >= 0 要严苛
                */
                right--;
            }
            //出循环之后right所指的数一定小于key，去填left处的坑
            swap(array,left,right);
            while(left < right && array[left] <= key) {
                left++;
            }
            //出循环之后left所指的数一定大于key，去填right处的坑
            swap(array,left,right);
        }
        /**
        1：最后right == left，right所经过的地方都是 >= key的
          left所经过的地方都是 <= key的，
        2：而且left与right相遇的时候一定有一个还是坑，所以相遇的地方就是个坑，直接把key放进去
        3：当right停下的时候，left所指的地方是坑，当left停下的时候，right所指的地方是坑，
          总之left与right来回交替着填坑。 
        */
        array[left] = key;
    }
    public static void swap(int[] array, int i,int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

重点：

之所以将你的key尽量的往前放是因为，当你的key在前面的时候，你从后往前找到小于key的数放在前面，

从前往后找找到大于key的数放在后面，这样前面的数都是小于key的后面的数都是大于key的，数不会乱。

如果你要找的key在中间，然后放数，数就会乱。

总之，将你要找的key放在最前面，然后先从后往前找，在从前往后找，循环进行，直到left = right

保证right所经过的数都 >= key , left所经过的数都小于等于key.

3：单指针法（左神）

在这里插入图片描述

// 思路
// 1：less只吃小于划分值的数，more只吃大于划分值的数，所以要保证less往前走的时候其前面的数要小划分值，more往前走的时       候其前面的数要大于划分值。
// 2：根据1这一特性，当index找到小于划分值的数时，就与less前面的数交换，将小数扔到less前面，                             同理当index找到大于划分值的数时，就与more前面的数交换，将大数扔到more前面。
// 3：当index指向等于划分值的数时，直接跳过就行。
// 4：这样两边一起向中间挤，最终剩下的就是等于划分值的数。

// 心得
// less走的时候，其前面的数永远时小于划分值的，同理more前面永远是大于划分值的。

package algorithmbasic.class6;

// 荷兰国旗问题
public class netherlandsFlag {
    // arr[L...R] 玩荷兰国旗问题的划分，以arr[R]做划分值
    // <arr[R] ==arr[R] > arr[R]
    public static int[] netherlandsFlag(int[] arr, int L, int R) {
        if (L > R) {
            return new int[]{Integer.MIN_VALUE, Integer.MIN_VALUE};
        }
        if (L == R) {
            return new int[]{L, R};
        }
        int less = L - 1;
        int more = R;
        int index = L;
        
        while (index < more) {
            if (arr[index] < arr[R]) {
                //swap(arr, index, less + 1);
                //less++;
                //index++;
                swap(arr, index++, ++less);
            } else if (arr[index] > arr[R]) {
                // 这个地方index不可以++，因为当前新换过来的数还并没有进行判断。
                swap(arr, index, --more);
            } else {
                index++;
            }
        }
        // 最后将划分值与more位置的的数进行交换。
        swap(arr, R, more);
        return new int[]{less + 1, more};
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

辗转相除法求最大公约数

最大公约数：

在这里插入图片描述

辗转相除法求最大公约数：

例一：

108 / 96 商：1 余：12

96 / 12 商：8 余：0

则最大公约数是：12

例二：

118 / 96 商：1 余：22

96 / 22 商：4 余：8

22 / 8 商：2 余：6

8 / 6 商：1 余：2

6 / 2 商：3 余：0

则最大公约数是2

辗转相除法的计算原理：

我们先计算出a除以b的余数c，把问题转化成求出b和c的最大公约数；然后计算出b除以c的余数d，把问题转化成求出c和d的最大公约数；再然后计算出c除以d的余数e，把问题转化成求出d和e的最大公约数…以此类推，逐渐把两个较大整数之间的运算简化成两个较小整数之间的运算，直到两个数可以整除，或者其中一个数减小到1为止。

快速排序的递归写法

在这里插入图片描述

// 思路：
// 1：设立一个划分值x，<x的放左边 =x的放右边 >x的放右边,这样x值的位置就排好了，并且左边都是小于x的，右边都是大于x的。
// 2：然后递归，将左边<x的按照1同样的方法进行，右侧也如此。
// 3：最后当递到一个数的时候就排好序了。

// 注意：
// 1：划分值的选择，划分值的选择是非常重要的。理想状态下每次最好的划分值x是：小于x的部分与大于x的部分个数是一样的。
//    这样尽可能的进行二分。时间复杂度保证为:N*logN，划分值偏太多会导致时间复杂度变为N^2
      swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
//    在arr[L , R]范围上随机找一个数作为划分值，虽然每一次都不均匀，但经过数学家计算，时间复杂度是NlogN. 图一：
// 2：递归的截止条件是
	    if (L >= R) {
            return;
        }
//    理想状态下是即有左组又有右组，这样尽可能的满足二分，但是有时会出现只有左组没有右组，或是只有右组没有左组的情况
//    如图2：当L = R时就一个数已经有序了不用再排了，直接返回。当L > R时，说明没有左组或者没有右组，也直接返回就行，不       返回就会报错。

// 心得：
// 递归的截止条件是
	    if (L >= R) {
            return;
        }
// 可能会出现没有左组huo'zh

图一：

在这里插入图片描述

图二：

在这里插入图片描述

package algorithmbasic.class6;

// 快排3.0 递归版本
public class quickSort {
    public static void quickSort(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        process(arr, 0, arr.length - 1);
    }

    // 递归函数：将arr[L , R]范围排有序
    public static void process(int[] arr, int L, int R) {
        // 注意点2
        if (L >= R) {
            return;
        }
        // 注意点1
        swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
        int[] equalArea = netherlandsFlag(arr, L, R);
        int el = equalArea[0];
        int er = equalArea[1];
        process(arr, L, el - 1);
        process(arr, er + 1, R);
    }


    // arr[L...R] 玩荷兰国旗问题的划分，以arr[R]做划分值
    // <arr[R] ==arr[R] > arr[R]
    public static int[] netherlandsFlag(int[] arr, int L, int R) {
        if (L > R) {
            return new int[]{Integer.MIN_VALUE, Integer.MIN_VALUE};
        }
        if (L == R) {
            return new int[]{L, R};
        }
        int less = L - 1;
        int more = R;
        int index = L;
        while (index < more) {
            if (arr[index] < arr[R]) {
                //swap(arr, index, less + 1);
                //less++;
                //index++;
                swap(arr, index++, ++less);
            } else if (arr[index] > arr[R]) {
                swap(arr, index, --more);
            } else {
                index++;
            }
        }
        swap(arr, R, more);
        return new int[]{less + 1, more};
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

快速排序的非递归写法

在这里插入图片描述

// 思路：
// 1：主要是用栈来实现递归。
//    具体步骤：先通过netherlandsFlag方法将整个arr[L , R]区间划分成区域1与区域2。将区域2压入栈中，再将区域1压入栈		  中，将区域1弹出，再通过netherlandsFlag方法将区域1划分成区域3与区域4，将区域3压入栈中，再将区域4压入栈中，再将       区域4弹出，再通过netherlandsFlag方法将区域4划分成区域5与区域6，将区域5压入栈中，再将区域6压入栈中，如此往复，我       们会发现压入栈中的都是区域的右半部分，当左半部分走到头的时候，递归就会“归”回来，将右半部分都完成。

图一：

在这里插入图片描述

package algorithmbasic.class6;

import java.util.Stack;

// 快速排序的非递归版本
public class quickSort2 {
    
    // 栈中存储的数据结构
    // 要处理的是什么范围上的排序
    public static class Op {
        int l;
        int r;
        public Op(int l, int r) {
            this.l = l;
            this.r = r;
        }
    }

    public static void quick(int[] arr) {
        if (arr == null || arr.length < 2) {
            return;
        }
        int N = arr.length;
        Stack<Op> stack = new Stack<>();
        // 划分值随机选择，使复杂度趋于N*logN
        swap(arr, (int) (Math.random() * N), N - 1);
        int[] equalArea = netherlandsFlag(arr, 0, N - 1);
        int el = equalArea[0];
        int er = equalArea[1];
        stack.push(new Op(er + 1, N - 1));
        stack.push(new Op(0, el - 1));
        while (!stack.isEmpty()) {
            Op op = stack.pop();
            // 先放右组后放左组
            // 当只有左组没有右组的时候,就会出现 : er + 1 > op.r 即：L > R
            // 当只有右组没有左组的时候，就会出现 :op.l > el - 1 即：L > R  图一
            // if之所以放在这个地方，而不是直接包含着Op op = stack.pop();原因是，不符合的区间需要被弹出。
            if (op.l < op.r) {
                swap(arr, (int) (op.l + Math.random() * (op.r - op.l + 1)), op.r);
                equalArea = netherlandsFlag(arr, op.l, op.r);
                el = equalArea[0];
                er = equalArea[1];
                stack.push(new Op(er + 1, op.r));
                stack.push(new Op(op.l, el - 1));
            }
        }
    }

    // arr[L...R] 玩荷兰国旗问题的划分，以arr[R]做划分值
    // <arr[R] ==arr[R] > arr[R]
    public static int[] netherlandsFlag(int[] arr, int L, int R) {
        if (L > R) {
            return new int[]{Integer.MIN_VALUE, Integer.MIN_VALUE};
        }
        if (L == R) {
            return new int[]{L, R};
        }
        int less = L - 1;
        int more = R;
        int index = L;
        while (index < more) {
            if (arr[index] < arr[R]) {
                //swap(arr, index, less + 1);
                //less++;
                //index++;
                swap(arr, index++, ++less);
            } else if (arr[index] > arr[R]) {
                swap(arr, index, --more);
            } else {
                index++;
            }
        }
        swap(arr, R, more);
        return new int[]{less + 1, more};
    }

    public static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}
chen森柏
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
概要入职培训 2023.4.11.xmind
01-12
概要入职培训 2023.4.11.xmind
pycharm-community-2023.2.5
03-25
4. **集成开发环境的扩展性**： 虽然社区版相对专业版在某些高级特性上有所限制，但它仍然具有良好的扩展性。用户可以通过安装插件来增强其功能，如支持Django、Flask等Web框架，或是增加对Jupyter Notebook的集成...
webstorm2023.3.4安装与破解
Aa12364567的博客
03-01 2479
打开JetBrains官方网站（https://www.jetbrains.com/webstorm/）运行.exe选择安装路径第一个意思是是否创建桌面快捷方式，可根据需要选择；第二个.js .css .html勾选后之后js css html文件默认会用webstorm打开点击“下一步”按钮继续安装。安装到此结束。
如何下载IDEA2023.3.4 最新激活破解教程
热门推荐
Li__Daxia的博客
02-19 2万+
如何快速安装IDEA20223.3.4 （附破解教程）
【操作系统】Kali Linux v2023.4 官方版（超详细，保姆级教程）
qq_47493625的博客
12-14 5385
其他镜像链接：（按需下载）：外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传在这里我选择的清华源，点击直链下载后面的链接进行下载。需要其他镜像文件的可以前往官网地址或者其他源镜站进行下载。
激活 安装 idea2023.3.3
weixin_46017666的博客
01-31 4467
注意这个路径 要更改自己的解压路径。下载这个解压到idea安装路径。
Kali Linux 2023.4 已经发布了！
网络研究观
12-07 3701
15 个新的附加工具
2023.11.4 软考信息安全工程师下午真题
qq_40424393的博客
11-04 2719
2023.11.4 信息安全工程师软考
IntelliJ IDEA 2023.2安装图文教程
分享思想，留下痕迹。
12-15 1694
大家好，我是Leo哥🫣🫣🫣，本期专栏带来一些开发中一些好用的工具，以及教大家如何去 “使用”，第一期带来的是当前最流行的JavaIDE----。好了，话不多说让我们开始吧😎😎😎。以上便是本文的全部内容，本人才疏学浅，文章有什么错误的地方，欢迎大佬们批评指正！我是Leo，一个在互联网行业的小白，立志成为更好的自己。如果你想了解更多关于Leo，可以关注公众号-程序员Leo，后面文章会首先同步至公众号。
ABB机器人编程仿真软件RobotStudio 2023.4.1-链接baiduyun.txt
01-16
ABB机器人编程仿真软件RobotStudio 2023.4.1-链接baiduyun
(4/4)kali-linux-2023.4-vmware-amd64.7z.004
01-05
kali-VM虚拟机
(1/5)kali-linux-2023.4-installer-amd64.zip.001
02-14
(1/5)kali镜像001
配置Java开发环境
最新发布
Broken_x的博客
07-10 1067
Java开发环境配置
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 275
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 1780
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
java Object 转 Integer
servepeople的博客
07-09 1180
在 Java 中，可以通过多种方法将一个Object转换为Integer。
2023.03.01-2023.03.03 2023.03.04-2023.03.10 2023.03.11-2023.03.17 2023.03.18-2023.03.24 2023.03.25-2023.03.31 按月划分周数，怎么用Java代码实现
05-26
第2周：2023.3.4-2023.3.10 第3周：2023.3.11-2023.3.17 第4周：2023.3.18-2023.3.24 第5周：2023.3.25-2023.3.31 ``` 该代码首先定义了要查询的年份和月份，然后使用 `Calendar` 类将日期设置为该月份的第一天。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

chen森柏

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值