（java）快速排序首先按数字对数字字符对进行排序，然后按字符进行排序

我修改了这里的算法：

要使用我的

节点

类：

public class Node
{
    public int frequency;
    public char value;
}

基本上，它应该首先按频率排序，然后如果频率相同，请查看char值

这是我的代码：

public static int partition(Node arr[], int left, int right)
{
      int i = left, j = right;
      Node tmp;
      int pivot = (left + right) / 2;

      while (i <= j) {
            while (arr[i].frequency < arr[pivot].frequency)
                  i++;
            while (arr[j].frequency > arr[pivot].frequency)
                  j--;
            if (i <= j) {

                if (arr[i].frequency == arr[j].frequency)
                {
                    if (arr[i].value > arr[j].value)
                    {
                        tmp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = tmp;                           
                    }
                }
                else //(arr[i].frequency > arr[j].frequency)
                {
                    tmp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = tmp;                           
                }

                i++;
                j--;
            }
      };

      return i;
}

public static void quickSort(Node arr[], int left, int right) {
      int index = partition(arr, left, right);
      if (left < index - 1)
            quickSort(arr, left, index - 1);
      if (index < right)
            quickSort(arr, index, right);
}

公共静态int分区（节点arr[]，int左，int右）
{
int i=左，j=右；
节点tmp；
int pivot=（左+右）/2；
while（i arr[pivot]。频率）
j--；
if（i arr[j].值）
{
tmp=arr[i]；
arr[i]=arr[j]；
arr[j]=tmp；
}
}
else/（arr[i].频率>arr[j].频率）
{
tmp=arr[i]；
arr[i]=arr[j]；
arr[j]=tmp；
}
i++；
j--；
}
};
返回i；
}
公共静态void快速排序（节点arr[]，左整数，右整数）{
int index=分区（arr、左、右）；
如果（左<索引-1）
快速排序（arr，左，索引-1）；
如果（索引<右）
快速排序（arr，索引，右侧）；
}

现在它确实有效，但它偶尔会漏掉一封信。只是想让它正常工作

感谢您的帮助

谢谢

---

编辑：感谢所有回答的人！我最终采用了类似的建议。现在天气很好

此处的评论不正确：

            else //(arr[i].frequency > arr[j].frequency)

if分支检查频率是否相同，因此在else中，在交换频率之前，您仍然必须检查它们的顺序是否正确

---

我建议编写一个单独的函数来比较节点。

此处的注释不正确：

            else //(arr[i].frequency > arr[j].frequency)

if分支检查频率是否相同，因此在else中，在交换频率之前，您仍然必须检查它们的顺序是否正确

---

我建议编写一个单独的函数来比较节点。

我建议您将比较2个

节点

对象移动到另一个方法，或者使

节点

具有可比性。我将在这里演示第二个选项

public class Node implements Comparable<Node> {
    public int frequency;
    public char value;

    @Override
    public int compareTo(Node o) {
        if(this.frequency < o.frequency)
            return -1;
        else if(this.frequency > o.frequency)
            return 1;
        else {
            if(this.value < o.value)
                return -1;
            else if(this.value > o.value)
                return 1;
            return 0;
        }
    }
}

public类节点实现可比较{
公共int频率；
公共价值；
@凌驾
公共整数比较（节点o）{
如果（该频率o频率）
返回1；
否则{
如果（该值o.value）
返回1；
返回0；
}
}
}

现在，不必在进行快速排序比较时检查两个字段，您只需执行类似于

if（arr[i].compareTo（arr[j]）<0的操作即可。如果有帮助，请告诉我。如果没有，我可以帮助编写更多的代码

对于排序，我建议使用
Arrays.sort（arr）
，现在您已经实现了
Comparable
。Edit。对于Java中的原语数组，此函数使用双枢轴快速排序，这非常酷。对于对象数组，使用
TimSort
。[]]
我建议您将比较2个
节点
对象移动到另一个方法，或者使
节点
具有可比性。我将在这里演示第二个选项

public class Node implements Comparable<Node> {
    public int frequency;
    public char value;

    @Override
    public int compareTo(Node o) {
        if(this.frequency < o.frequency)
            return -1;
        else if(this.frequency > o.frequency)
            return 1;
        else {
            if(this.value < o.value)
                return -1;
            else if(this.value > o.value)
                return 1;
            return 0;
        }
    }
}

public类节点实现可比较{
公共int频率；
公共价值；
@凌驾
公共整数比较（节点o）{
如果（该频率o频率）
返回1；
否则{
如果（该值o.value）
返回1；
返回0；
}
}
}

现在，不必在进行快速排序比较时检查两个字段，您只需执行类似于
if（arr[i].compareTo（arr[j]）<0的操作即可。如果有帮助，请告诉我。如果没有，我可以帮助编写更多的代码

对于排序，我建议使用
Arrays.sort（arr）
，现在您已经实现了
可比较的
。Edit。对于Java中的原语数组，此函数使用双枢轴快速排序，这非常酷。对于对象数组，使用
TimSort
。[][]
这里有5种方法可以做到这一点（您可以添加更多）：

就这样


对代码进行编辑后说：

package AR;

class Node {
    public int frequency;
    public char value;

    public Node(int frequency, char value) {
        this.frequency = frequency;
        this.value = value;
    }
}

final class Sort {

    int partition(Node arr[], int left, int right) {
        int i = left, j = right;
        Node tmp;
        Node pivot = arr[(left + right) / 2];

        while (i <= j) {
            while (i <= j && (arr[i].frequency < pivot.frequency || (arr[i].frequency == pivot.frequency && arr[i].value < pivot.value)))
                i++;
            while (i <= j && (arr[j].frequency > pivot.frequency || (arr[j].frequency == pivot.frequency && arr[j].value > pivot.value)))
                j--;
            if (i <= j) {
                tmp = arr[i];
                arr[i] = arr[j];
                arr[j] = tmp;
                i++;
                j--;
            }
        }
        return i;
    }

    public void quickSort(Node arr[], int left, int right) {
        if (left > right) return;
        int index = partition(arr, left, right);
        if (left < index - 1)
            quickSort(arr, left, index - 1);
        if (index < right)
            quickSort(arr, index, right);
    }
}

final class Main {
    public static void main(String[] args) {

        Node[] ns = new Node[]{new Node(10, 'a'), new Node(10, 'c'), new Node(8, 'a'), new Node(1, 'b'), new Node(10, 'a'), new Node(10, 'b'), new Node(8, 'a'), new Node(1, 'b'), new Node(10, 'a'), new Node(10, 'b'), new Node(8, 'a'), new Node(1, 'b'), new Node(0, 'z'), new Node(1, 'z')};
        int n = ns.length;
        Sort cl = new Sort();
        cl.quickSort(ns, 0, n - 1);
        for (int i = 0; i < n; i++) {
            System.out.print("(" + ns[i].frequency + "," + ns[i].value + "), ");
            //(0,z), (1,b), (1,b), (1,b), (1,z), (8,a), (8,a), (8,a), (10,a), (10,a), (10,a), (10,b), (10,b), (10,c),
        }
    }
}

封装AR；
类节点{
公共int频率；
公共价值；
公共节点（整数频率、字符值）{
这个频率=频率；
这个值=值；
}
}
最终类排序{
int分区（节点arr[]，int左，int右）{
int i=左，j=右；
节点tmp；
节点轴=arr[（左+右）/2]；
而（输入输出频率）返回1；
if（this.frequencyo.value）返回1；
如果（this.valueo.value）返回1；
如果（this.valuepackage AR;
class Node implements Comparable<Node> {
    public int frequency;
    public char value;
    public Node(int frequency, char value) {
        this.frequency = frequency;
        this.value = value;
    }
    @Override
    public int compareTo(Node o) {
        if (this.frequency > o.frequency) return 1;
        if (this.frequency < o.frequency) return -1;
        if (this.value > o.value) return 1;
        if (this.value < o.value) return -1;
        return 0;
    }
}
final class Main {
    static void swap(Node[] arr, int i, int j) {
        Node temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
    static int partition(Node[] arr, int left, int right) {
        int i = left;
        Node pivot = arr[left++];
        while (left <= right) {
            while (left <= right && arr[left].compareTo(pivot) <= 0) left++;
            while (left <= right && arr[right].compareTo(pivot) > 0) right--;
            if (left > right)break;
            swap(arr, left++, right--);
        }
        swap(arr, i, right);
        return right;
    }
    public static void quickSort(Node arr[], int left, int right) {
        if (left >= right) return;
        int i = partition(arr, left, right);
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }
    public static void main(String[] args) {

        Node[] ns = new Node[]{new Node(10, 'a'), new Node(10, 'b'), new Node(8, 'a'), new Node(1, 'b'), new Node(10, 'a'), new Node(10, 'b'), new Node(8, 'a'), new Node(1, 'b'), new Node(10, 'a'), new Node(10, 'b'), new Node(8, 'a'), new Node(1, 'b'), new Node(0, 'z'), new Node(1, 'z')};
        int n = ns.length;
        quickSort(ns, 0, n - 1);
        for (int i = 0; i < n; i++) {
            System.out.print("(" + ns[i].frequency + "," + ns[i].value + "), ");
            //(0,z), (1,b), (1,b), (1,b), (1,z), (8,a), (8,a), (8,a), (10,a), (10,a), (10,a), (10,b), (10,b), (10,b), 
        }
    }
}

package AR;

class Node implements Comparable<Node> {
    public int frequency;
    public char value;

    public Node(int frequency, char value) {
        this.frequency = frequency;
        this.value = value;
    }

    @Override
    public int compareTo(Node o) {
        if (this.frequency > o.frequency) return 1;
        if (this.frequency < o.frequency) return -1;
        if (this.value > o.value) return 1;
        if (this.value < o.value) return -1;
        return 0;
    }
}

final class Sort<T extends Comparable<T>> {
    void swap(T[] arr, int i, int j) {
        T temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    int partition(T[] arr, int left, int right) {
        int i = left;
        T pivot = arr[left++];
        while (left <= right) {
            while (left <= right && arr[left].compareTo(pivot) <= 0) left++;
            while (left <= right && arr[right].compareTo(pivot) > 0) right--;
            if (left > right) break;
            swap(arr, left++, right--);
        }
        swap(arr, i, right);
        return right;
    }

    public void quickSort(T arr[], int left, int right) {
        if (left >= right) return;
        int i = partition(arr, left, right);
        quickSort(arr, left, i - 1);
        quickSort(arr, i + 1, right);
    }

}

final class Main {
    public static void main(String[] args) {

        Node[] ns = new Node[]{new Node(10, 'a'), new Node(10, 'c'), new Node(8, 'a'), new Node(1, 'b'), new Node(10, 'a'), new Node(10, 'b'), new Node(8, 'a'), new Node(1, 'b'), new Node(10, 'a'), new Node(10, 'b'), new Node(8, 'a'), new Node(1, 'b'), new Node(0, 'z'), new Node(1, 'z')};
        int n = ns.length;
        Sort cl = new Sort();
        cl.quickSort(ns, 0, n - 1);
        for (int i = 0; i < n; i++) {
            System.out.print("(" + ns[i].frequency + "," + ns[i].value + "), ");
            //(0,z), (1,b), (1,b), (1,b), (1,z), (8,a), (8,a), (8,a), (10,a), (10,a), (10,a), (10,b), (10,b), (10,c),
        }
    }
}