class05

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

一、快速排序（递归版）

1、了解荷兰国旗划分问题

1.小于X的放左边，大于X的放右边（左右）
(<= 区)[2,5,1,2,3] 目标 4
   当前数 <= 目标，当前数和(<= 区)下一个数交换，(<= 区向右扩)，当前数跳下一个
   当前数 > 目标，当前数跳下一个
    
2.小于X的放左边，等于X的放中间，大于X的放右边（左中右）
(< 区)[2,5,1,3,4](> 区) 目标 4
   当前数 < 目标，当前数和(< 区)下一个数交换，(< 区)向右扩，当前数跳下一个
   当前数 = 目标，当前数直接跳下一个
   当前数 > 目标，当前数和(> 区)前一个数交换，(> 区)向左扩，当前数停在原地（因为交换来的数还没看过）

  • 快排 1.0 版本：O(N^2)，2个区域（小于等于arr[R],大于arr[R]）,一次搞定一个数

    public void quickSort(int[] arr) {
    if(arr == null || arr.length < 2) {
        return;
    }
    process(arr, 0, arr.length - 1);
}

public void process(int[] arr, int L, int R) {
    // base case
    if(L >= R) {
        return;
    }
    // 荷兰国旗划分 L..R partition arr[R] [ <=arr[R] arr[R] >arr[R] ]
    int M = partition(arr, L, R);
    // 左边递归
    process(arr, L, M - 1);
    // 右边递归
    process(arr, M + 1, R);
}
// arr[L..R]上，以arr[R]位置的数做划分值
public int partition(int[] arr, int L, int R) {
    if(L > R) {
        return -1;
    }
    if(L == R) {
        return L;
    }
    // 小于等于 X 的下标位置
    int lessEqual = L - 1;
    // 开始比较的下标
    int index = L;
    while(index < R) {
        // 当前位置值小于等于最后一个目标值时，小于等于区域往右扩，并交换当前位置的值
        if(arr[index] <= arr[R]) {
            // 交换
            swap(arr, index, ++lessEqual);
        }
        // 继续下一个位置
        index++;
    }
    // 交换最后一个位置到合适的位置
    swap(arr, ++lessEqual, R);
    return lessEqual;
}
// 交换元素方法
public void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

    选取数组中最后一个位置的数作目标数，左边界一直往右扩

  • 快排 2.0 版本：O(N^2)，3个区域（小于arr[R],大于arr[R],大于arr[R]）,一次搞定一批与目标相等的数

    public void quickSort(int[] arr) {
    if(arr == null || arr.length < 2) {
        return;
    }
    process(arr, 0, arr.length - 1);
}
// 递归过程
public void process(int[] arr, int L, int R) {
    // base case
    if(L >= R) {
        return;
    }
    // [eqaulArea[0],eqaulArea[1]]
    int[] equalArea = partition(arr, L, R);
    // 左边递归
    process(arr, L, eqaulArea[0] - 1);
    // 右边递归
    process(arr, eqaulArea[1] +1, R);
}
// 荷兰国旗划分
public int[] partition(int[] arr, int L, int R) {
    if(L > R) {
        return new int[]{-1, -1};
    }
    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]) {
            // 当前数与目标数相等，当前位置直接跳下一个
            index++;
        } else if(arr[index] < arr[R]) {
            // 当前数小于目标数，当前数与小于区域右边的一个数交换，当前位置跳下一个，小于区域右扩
            swap(arr, index++, ++less);
        } else {
            // 当前数大于目标数，当前数与大于区域左边的一个数交换，当前位置不变(交换的还没看)，大于区域左阔
            swap(arr, index, --more);
        }
    }
    // arr[R]目标数交换到合适位置，放到等于区域
    swap(arr, more, R);
    // 返回等于区域的区间范围边界
    return new int[]{less + 1, more};
}
// 交换
public void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

    选取数组最后一个位置的数为目标数，小于区域往右扩，大于区域往左扩

  • 快排 3.0 版本：随机快排O(N*logN), 不再使用最后一个数作为目标，随机在L…R选择一个交换到最后来作为目标

    public void quickSort(int[] arr) {
    if(arr == null || arr.length < 2) {
        return;
    }
    process(arr, 0, arr.length - 1);
}
// 递归方法
public void process(int[] arr, int L,int R) {
    // base case
    if(L >= R) {
        return;
    }
    // 随机选择一个数作为目标数，交换到最后一个位置
    swap(arr, L + (int) (Math.random() * (R - L + 1)), R);
    int[] equalArea = process(arr, L, R);
    // 左边递归
    process(arr, L, equalArea[0] - 1);
    // 右边递归
    process(arr, equalArea[1] + 1);
}
// 荷兰国旗划分
public int[] partition(int[] arr, int L, int R) {
    if(L > R) {
        return new int[]{-1, -1};
    }
    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]) {
            // 当前数与目标数相等，当前位置直接跳下一个
            index++;
        } else if(arr[index] < arr[R]) {
            // 当前数小于目标数，当前数与小于区域右边的一个数交换，当前位置跳下一个，小于区域右扩
            swap(arr, index++, ++less);
        } else {
            // 当前数大于目标数，当前数与大于区域左边的一个数交换，当前位置不变(交换的还没看)，大于区域左阔
            swap(arr, index, --more);
        }
    }
    // arr[R]目标数交换到合适位置，放到等于区域
    swap(arr, more, R);
    // 返回等于区域的区间范围边界
    return new int[]{less + 1, more};
}
// 交换
public void swap(int[] arr, int i, int j) {
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

    随机选择一个位置作为目标数

二、快速排序（非递归版）

  • 使用栈来实现

    // 快排非递归版本需要的辅助类
// 要处理的是什么范围上的排序
public static class Op {
    public int l;
    public int r;

    public Op(int left, int right) {
        l = left;
        r = right;
    }
}
// 快排3.0 非递归版本 用栈来执行
public void quickSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int N = arr.length;
    // 随机选择一个位置的数作为目标，交换到最后
    swap(arr, (int) (Math.random() * N), N - 1);
    // 荷兰国旗划分一次，得到两个区间（左右）
    int[] equalArea = partition(arr, 0, N - 1);
    int el = equalArea[0];
    int er = equalArea[1];
    Stack<Op> stack = new Stack<>();
    // 压入得到的左右区间到栈中
    stack.push(new Op(0, el - 1));
    stack.push(new Op(er + 1, N - 1));
    // 栈调用
    while (!stack.isEmpty()) {
        // 弹出一个区间
        Op op = stack.pop(); // op.l ... op.r
        if (op.l < op.r) {
            // 再次随机选择一个位置的数作为目标，交换到最后位置
            swap(arr, op.l + (int) (Math.random() * (op.r - op.l + 1)), op.r);
            // 荷兰国旗划分，再次得到两个区间（左右）
            equalArea = partition(arr, op.l, op.r);
            el = equalArea[0];
            er = equalArea[1];
            // 再次将得到的左右区间压入到栈中
            stack.push(new Op(op.l, el - 1));
            stack.push(new Op(er + 1, op.r));
        }
    }
}
// 荷兰国旗问题
public int[] process(int[] arr, int L, int R) {
    if (L > R) {
        return new int[] { -1, -1 };
    }
    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]) {
            index++;
        } else if (arr[index] < arr[R]) {
            swap(arr, index++, ++less);
        } else {
            swap(arr, index, --more);
        }
    }
    swap(arr, more, R);
    return new int[] { less + 1, more };
}

  • 使用队列来实现

    // 快排非递归版本需要的辅助类
// 要处理的是什么范围上的排序
public static class Op {
    public int l;
    public int r;

    public Op(int left, int right) {
        l = left;
        r = right;
    }
}
// 快排3.0 非递归版本 用队列来执行
public static void quickSort(int[] arr) {
    if (arr == null || arr.length < 2) {
        return;
    }
    int N = arr.length;
    swap(arr, (int) (Math.random() * N), N - 1);
    int[] equalArea = process(arr, 0, N - 1);
    int el = equalArea[0];
    int er = equalArea[1];
    Queue<Op> queue = new LinkedList<>();
    queue.offer(new Op(0, el - 1));
    queue.offer(new Op(er + 1, N - 1));
    while (!queue.isEmpty()) {
        Op op = queue.poll();
        if (op.l < op.r) {
            swap(arr, op.l + (int) (Math.random() * (op.r - op.l + 1)), op.r);
            equalArea = process(arr, op.l, op.r);
            el = equalArea[0];
            er = equalArea[1];
            queue.offer(new Op(op.l, el - 1));
            queue.offer(new Op(er + 1, op.r));
        }
    }
}
// 荷兰国旗问题
public int[] process(int[] arr, int L, int R) {
    if (L > R) {
        return new int[] { -1, -1 };
    }
    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]) {
            index++;
        } else if (arr[index] < arr[R]) {
            swap(arr, index++, ++less);
        } else {
            swap(arr, index, --more);
        }
    }
    swap(arr, more, R);
    return new int[] { less + 1, more };
}

三、快速排序（双向链表版）

较为复杂 - 了解即可

public static class Node {
    public int value;
    public Node last;
    public Node next;

    public Node(int v) {
        value = v;
    }
}

public static Node quickSort(Node h) {
    if (h == null) {
        return null;
    }
    int N = 0;
    Node c = h;
    Node e = null;
    while (c != null) {
        N++;
        e = c;
        c = c.next;
    }
    return process(h, e, N).h;
}

public static class HeadTail {
    public Node h;
    public Node t;

    public HeadTail(Node head, Node tail) {
        h = head;
        t = tail;
    }
}

// L...R是一个双向链表的头和尾,
// L的last指针指向null，R的next指针指向null
// 也就是说L的左边没有，R的右边也没节点
// 就是一个正常的双向链表，一共有N个节点
// 将这一段用随机快排的方式排好序
// 返回排好序之后的双向链表的头和尾(HeadTail)
public static HeadTail process(Node L, Node R, int N) {
    if (L == null) {
        return null;
    }
    if (L == R) {
        return new HeadTail(L, R);
    }
    // L..R上不只一个节点
    // 随机得到一个随机下标
    int randomIndex = (int) (Math.random() * N);
    // 根据随机下标得到随机节点
    Node randomNode = L;
    while (randomIndex-- != 0) {
        randomNode = randomNode.next;
    }
    // 把随机节点从原来的环境里分离出来
    // 比如 a(L) -> b -> c -> d(R), 如果randomNode = c，那么调整之后
    // a(L) -> b -> d(R), c会被挖出来，randomNode = c
    if (randomNode == L || randomNode == R) {
        if (randomNode == L) {
            L = randomNode.next;
            L.last = null;
        } else {
            randomNode.last.next = null;
        }
    } else { // randomNode一定是中间的节点
        randomNode.last.next = randomNode.next;
        randomNode.next.last = randomNode.last;
    }
    randomNode.last = null;
    randomNode.next = null;
    Info info = partition(L, randomNode);
    // <randomNode的部分去排序
    HeadTail lht = process(info.lh, info.lt, info.ls);
    // >randomNode的部分去排序
    HeadTail rht = process(info.rh, info.rt, info.rs);
    // 左部分排好序、右部分排好序
    // 把它们串在一起
    if (lht != null) {
        lht.t.next = info.eh;
        info.eh.last = lht.t;
    }
    if (rht != null) {
        info.et.next = rht.h;
        rht.h.last = info.et;
    }
    // 返回排好序之后总的头和总的尾
    Node h = lht != null ? lht.h : info.eh;
    Node t = rht != null ? rht.t : info.et;
    return new HeadTail(h, t);
}

public static class Info {
    public Node lh;
    public Node lt;
    public int ls;
    public Node rh;
    public Node rt;
    public int rs;
    public Node eh;
    public Node et;

    public Info(Node lH, Node lT, int lS, Node rH, Node rT, int rS, Node eH, Node eT) {
        lh = lH;
        lt = lT;
        ls = lS;
        rh = rH;
        rt = rT;
        rs = rS;
        eh = eH;
        et = eT;
    }
}

// (L....一直到空)，是一个双向链表
// pivot是一个不在(L....一直到空)的独立节点，它作为划分值
// 根据荷兰国旗问题的划分方式，把(L....一直到空)划分成:
// <pivot 、 =pivot 、 >pivot 三个部分，然后把pivot融进=pivot的部分
// 比如 4(L)->6->7->1->5->0->9->null pivot=5(这个5和链表中的5，是不同的节点)
// 调整完成后:
// 4->1->0 小于的部分
// 5->5 等于的部分
// 6->7->9 大于的部分
// 三个部分是断开的
// 然后返回Info：
// 小于部分的头、尾、节点个数 : lh,lt,ls
// 大于部分的头、尾、节点个数 : rh,rt,rs
// 等于部分的头、尾 : eh,et
public static Info partition(Node L, Node pivot) {
    Node lh = null;
    Node lt = null;
    int ls = 0;
    Node rh = null;
    Node rt = null;
    int rs = 0;
    Node eh = pivot;
    Node et = pivot;
    Node tmp = null;
    while (L != null) {
        tmp = L.next;
        L.next = null;
        L.last = null;
        if (L.value < pivot.value) {
            ls++;
            if (lh == null) {
                lh = L;
                lt = L;
            } else {
                lt.next = L;
                L.last = lt;
                lt = L;
            }
        } else if (L.value > pivot.value) {
            rs++;
            if (rh == null) {
                rh = L;
                rt = L;
            } else {
                rt.next = L;
                L.last = rt;
                rt = L;
            }
        } else {
            et.next = L;
            L.last = et;
            et = L;
        }
        L = tmp;
    }
    return new Info(lh, lt, ls, rh, rt, rs, eh, et);
}
`Oracle`
关注
专栏目录
Unrecognized configuration class ＜class ‘transformers_modules.chatglm2-6b.configuration_chatglm.解决方案
weixin_43178406的博客
12-10 5万+
本文主要介绍了Unrecognized configuration class for this kind of AutoModel: AutoModelForCausalLM.解决方案，希望能对使用chatglm的同学们有所帮助。 文章目录 1. 问题描述 2. 解决方案
python中class什么意思_python中的class是什么意思
weixin_39896839的博客
11-25 6585
python中的class是什么意思发布时间：2020-08-05 17:44:47来源：亿速云阅读：91作者：小新python中的class是什么意思？这个问题可能是我们日常学习或工作经常见到的。希望通过这个问题能让你收获颇深。下面是小编给大家带来的参考内容，让我们一起来看看吧！面向对象的设计思想是从自然界中来的，因为在自然界中，类（Class）和实例（Instance）的概念是很自然的。Cla...
classNum 表示学生的班号，例如“class05”。 有如下List  List list = new ArrayList();...
diaolianxian9049的博客
09-27 1428
package a927; import java.util.ArrayList; import java.util.List; class Student { private String name ; private int age ; private int score ; private String classNum ...
Scala之case class
李鬼989的专栏
04-29 1万+
我们在模式匹配中可以见到case a match { case b => ... case _ => ... } 我们在类定义时，有时也会见到case关键字 case class Person (age: Int, name: String) 那么，在类上加上case关键字意味着什么呢? 伴生对象 编译Person.scala会产生两个class, Person.c...
java 编译class_.java文件怎样编译成.class文件，你值得一看的技巧
weixin_39638801的博客
02-20 1万+
以.java结尾的文件是java的源文件，存放的是我们编写的java源代码。.class结尾的文件是java的字节码文件，里面存放的是我们对java源码编译后产生的二进制代码。接下来小编和大家分享下如何将.java文件编译成.class文件。工具/材料JDK操作方法01首先，我们必须在电脑上安装JDK(java 开发工具包)。我们可以在官网上进行下载。02安装完成后，我们需要配置环境变量。我们将J...
设备管理 USB class
a624731186的专栏
12-27 1742
发现一个USB class网站，对设备管理的小伙伴非常有用 http://www.usb.org/developers/defined_class USB Class Codes                     August 11, 2014 USB defines class code information that is used to ident
Class -- 05 -- TimeUnit类常用方法解析
Gene Xu
08-12 3578
这次主要整理下Java中TimeUnit类的常用方法 一、TimeUnit类的定义 TimeUnit类是一个枚举类，主要用于时间颗粒度的转换与线程的延时 TimeUnit主要包含了以下几个枚举常量 SECONDS：秒 MINUTES：分 HOURS：时 DAYS：日 NANOSECONDS：纳秒，等于1∗10−9s1∗10−9s1 * 10^{-9}s MICROSECONDS：微秒，...
Class -- 09 -- Field类常用方法解析
Gene Xu
11-11 8718
这次主要整理下Java中Field类的常用方法 一、Field类的定义 Field类位于 java.lang.reflect 包中，主要用于在程序运行状态中，动态地获取或设置字段参数信息 二、Field类的常用方法 &amp;amp;amp;nbsp; 1、getAnnotatedType() 返回一个AnnotatedType对象，该对象表示使用类型来指定该字段对象表示的字段的声明类型 public cla...
Class -- 10 -- Method类常用方法解析
热门推荐
Gene Xu
11-17 1万+
这次主要整理下Java中Method类的常用方法 一、Method类的定义 Method类位于 java.lang.reflect 包中，主要用于在程序运行状态中，动态地获取方法信息 二、Method类的常用方法 &amp;amp;amp;amp;nbsp; 1、getAnnotatedReturnType() 返回一个AnnotatedType对象，该对象表示使用一个类型来指定由该可执行文件表示的方法/构造函数的返回...
Class -- 07 -- Modifier类常用方法解析
Gene Xu
10-14 4636
这次主要整理下Java中Modifier类的常用方法 一、Modifier类的定义 Modifier类 (修饰符工具类) 位于 java.lang.reflect 包中，用于判断和获取某个类、变量或方法的修饰符 Modifier类将各个修饰符表示为相对应的整数，在源码中用16进制进行表示 静态常量 public：Modifier.PUBLIC (0x00000001) (1) private...
FirePHP.class_05leb0_FirePHP_
10-01
"FirePHP.class_05leb0_FirePHP_" 提供了一种高效的方法来实现这一目标。这个命名可能暗示着它是一个实现了FirePHP接口的类，FirePHP是一个流行的PHP调试工具，它允许开发者通过Firefox浏览器的Firebug扩展来查看PHP...
05v-bind操作class.html
03-08
05v-bind操作class.html
Een-classy-element-05a98c36
03-28
Een-Classy-element-05a98c36
28-05-2020-csharp-class-NigarFS：28-05-2020-csharp-class-NigarFS由GitHub Classroom创建
02-18
02.05.2020-csharp-class Oxumalıolduğunuzmateriallar C＃类和对象 从c＃OOP-> c＃属性 塔布西里克 “发票” adinda bir类yaradin hansi ki ozunde asagindaki 3 fieldleri 字符串帐户字符串客户字符串提供者 ...
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 417
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 526
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1227
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
阿呆的专栏
10-01 792
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 321
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值