Java三种方法实现字符串排序

「爱情、让人受尽委屈。」 2022-10-25 04:43 720阅读 0赞

## Java字符串排序 ##

### 文章目录 ###

*   *  Java字符串排序
     *   *  排序方法概述
         *  键索引计数法
         *  低位优先的字符串排序（LSD）
         *  高位优先的字符串排序（MSD）
         *  三向字符串快速排序

--------------------

### 排序方法概述 ###

对于许多应用，决定顺序的键都是字符串。本篇讲述如何利用字符串的特殊性质来对其进行高效的排序。

第一类方法会从右到左检查键中的字符。这种方法一般被称为**低位优先**（`Least-Significant-DigitFirst`，`LSD`）的字符串排序。如果将一个字符串看做一个256进制的数字，那么从右向左检查字符串就等价于先检查数字的最低位。这种方法最适合用于键的长度都相同的字符串排序应用。

第二类方法会从左到右检查键中的字符，首先查看的是最高位的字符。这种方法通常称为**高位优先**（`MSD`）的字符串排序。高位优先的字符串排序和快速排序类似，因为它们都会将需要排序的数组切分为独立的部分并递归地用相同的方法处理子数组来完成排序。它们的区别之处在于高位优先的字符串排序算法在切分时仅使用键的第一个字符，而快速排序的比较则会涉及键的全部。

第三种方法是高位优先的字符串排序算法的改进`快速排序`，根据键的首字母进行三向切分，仅在中间子数组中的下一个字符（因为键的首字母都与切分字符相等）继续递归排序。

### 键索引计数法 ###

作为热身，我们先学习一种适用于小整数键的简单排序方法。这种叫做`键索引计数`的方法本身就很实用，同时也是要学习的三种排序算法中前两种的基础。它其实就**桶计数**。

现在来情景引入，老师在统计学生的分数时可能会遇到以下数据处理问题。学生被分为若干组，标号为1、2、3、4等。在某些情况下，我们希望将全班同学按组分类。因为组的编号是较小的整数，使用键索引计数法来排序时很合适的。假设数组`a[]`中的每个元素都保存了一个名字和一个组号，其中组号在`0到R-1`之间，代码`a[i].key()`会返回指定学生的组号。四个步骤见代码

int N = a.length;
    int R = 256;    //R为字符基数
    
    String[] aux = new String[N];
    int[] count = new int[R + 1];
    
    //计算出现频率
    for (int i = 0; i < N; i++) 
        count[a[i].key() + 1]++;
    
    //将频率转换为索引
    for (int r = 0; r < R; r++) 
        count[r + 1] += count[r];
    
    //将元素分类
    for (int i = 0; i < N; i++) 
        aux[count[a[i].key()]++] = a[i];
    
    //回写
    for (int i = 0; i < N; i++)
        a[i] = aux[i];

`命题A`：键索引计数法排序`N`个键为`0`到`R-1`之间的整数的元素需要访问数组`11N+4R+1`次

### 低位优先的字符串排序（LSD） ###

如果字符串的长度均为`W`，那就从右向左以每个位置的字符作为键，用键索引计数法将字符串排序`W`遍。

`命题B`：低位优先的字符串排序算法能够稳定地将**定长**字符串排序

class LSD{
        
    	// Least-Significant-Digit First
    	//低位优先的字符串排序(基数排序)
    	public static void sort(String[] a, int W) {
        
    		//通过前W个字符将a[]排序
    		int N = a.length;
    		int R = 256;    //基数
    		String[] aux = new String[N];  //辅助数组\
    
    		for(int d = W - 1; d >= 0; d--) {
        
    			//根据第d个字符用键索引计数法排序
    			int[] count = new int[R + 1];   
    			//计算出现频率
    			for (int i = 0; i < N; i++)
    				count[a[i].charAt(d) + 1]++;
    			//将频率转换为索引
    			for (int r = 0; r < R; r++)
    				count[r + 1] += count[r];
    			//将元素分类
    			for (int i = 0; i < N; i++) 
    				aux[count[a[i].charAt(d)]++] = a[i];
    			//回写
    			for (int i = 0; i < N; i++) 
    				a[i] = aux[i];
    		}
    	}
    }

在许多字符串排序的应用中，键的长度可能互不相同。改进后的低位优先的字符串排序是可以适应这些情况的。下来讲解两种处理变长键排序的算法

### 高位优先的字符串排序（MSD） ###

首先用键索引计数法将所有字符串按照首字母排序，然后（递归地）再将每个首字母所对应的子数组排序（忽略首字母，因为每一类中的所有首字母都是相同的）。和快速排序一样，高位优先的字符串排序会将数组切分为能够独立排序的子数组来完成排序任务，但它的切分会为每个首字母得到一个子数组，而不是像快速排序中那样产生固定的两个或者三个切分。

在高位优先的字符串排序算法中，要特别注意到达字符串末尾的情况。在排序中，合理的做法是将所有字符都已被检查过的字符串所在的子数组排在所有子数组的前面，这样就不需要递归地将该子数组排序。为了简化这两步计算，我们使用了一个接受两个参数的私有方法`charAt()`来将字符串中字符索引转化为数组索引，当指定的位置超过了字符串末尾时该方法返回`-1`,。然后将所有返回值加1，得到一个非负的int值并用它作为`count[]`的索引。这种转换意味着字符串中的每个字符都可能产生`R+1`种不同的值：0表示字符串的结尾，1表示字符串的第一个字符，2表示字符串的第二个字符，等等。因为建索引计数法本来就需要一个额外的位置，所以使用代码`int count[] = new int[R + 2]`

class MSD{
        
    	//高位优先的字符串排序
    	private static int R = 256;      //基数
    	private static final int M = 15; //小数组的切换阈值
    	private static String[] aux;     //数组分类的辅助数组
    	private static int charAt(String s, int d) {
        
    		if(d < s.length()) {
        
    			return s.charAt(d);
    		}else {
        
    			return -1;
    		}
    	}
    	public static void sort(String[] a) {
        
    		int N = a.length;
    		aux = new String[N];
    		sort(a, 0, N - 1, 0);
    	}
    	private static void sortInsert(String[] a, int lo, int hi) {
        
    		//小型数组进行插入排序
    		for (int i = lo + 1; i <= hi; i++) {
        
    			for(int j = i; j > lo && a[j].compareTo(a[j - 1]) < 0; j--) {
        
    				String tmp = a[j];
    				a[j] = a[j - 1];
    				a[j - 1] = tmp;
    			}
    		}
    	}
    	private static void sort(String[] a, int lo, int hi, int d) {
        
    		//以第d个字符为键将a[lo]至a[hi]排序
    		if(hi <= lo + M) {
        
    			sortInsert(a, lo, hi);
    			return; 
    		}
    		int [] count = new int[R + 2];    //计算频率
    		for(int i = lo; i <= hi; i++) {
        
    			count[charAt(a[i], d) + 2]++;
    		}
    		for(int r = 0; r < R + 1; r++) {
          //将频率转换为索引
    			count[r + 1] += count[r];
    		}
    		for(int i = lo; i <= hi; i++) {
           //数据分类
    			aux[count[charAt(a[i], d) + 1]++] = a[i];
    		}
    		for(int i = lo; i <= hi; i++) {
           //回写
    			a[i] = aux[i - lo]; 
    		}
    		//递归的以每个字符为键进行排序
    		for(int r = 0; r <R; r++) {
        
    			sort(a, lo + count[r], lo + count[r + 1] - 1, d + 1);
    		}
    	}
    }

### 三向字符串快速排序 ###

我们也可以根据高位优先的字符串排序算法改进快速排序，根据键的首字母进行三向切分，仅在中间子数组的下一个字符（因为键得出首字母都与切分字母相同）继续递归排序。这个算法的实现并不困难，参考往期排序算法中的三向切分快排即可。

尽管排序的方式有所不同，但三向字符串快速排序根据的仍然是键的首字母并使用递归的方法将其余部分排序。对于字符串的排序，这个方法比普通的快速排序和高位优先的字符串排序更友好。实际上，它就是两种算法的结合。

三向字符串快速排序只将数组切分为三部分，因此当相应的高位优先的字符串排序产生的非空切分较多时，它需要移动的数据量就会变大，因此它需要进行一系列的三向切分才能够取得多向切分的效果。但是，高位优先的字符串排序可能会创建大量（空）子数组，而三向字符串快速排序的切分总是只有三个。因此三向字符串快速排序能够很好地处理`等值键、有较长公共前缀的键、取值范围较小的键和小数组`\-----所有高位优先的字符串排序算法不擅长的各种情况。

class Quick3string{
        
    	//三向字符串快速排序
    	private static int charAt(String s, int d) {
        
    		if(d < s.length()) {
        
    			return s.charAt(d);
    		}
    		return -1;
    	}
        
    	public static void sort(String[] a) {
        
    		sort(a, 0, a.length - 1, 0);
    	}
        
    	private static void sort(String[] a, int lo, int hi, int d) {
        
    		if(hi <= lo) {
        
    			return;
    		}
    		int lt = lo, gt = hi, i = lo + 1;
    		int v = charAt(a[lo], d);
    		while(i <= gt) {
        
    			int t = charAt(a[i], d);
    			if(t < v) {
        
    				exch(a, lt++, i++);
    			}else if(t > v) {
        
    				exch(a, i, gt--);
    			}else {
        
    				i++;
    			}
    		}
    		//a[lo..lt-1] < v = a[lt..gt] < a[gt+1..hi]
    		sort(a, lo, lt - 1, d);
    		if(v >= 0) {
        
    			sort(a, lt, gt, d + 1);
    		}
    		sort(a, gt + 1, hi, d);
    	}
        
    	private static void exch(String[] a, int i, int j) {
        
    		String t = new String(a[i]);
    		a[i] = a[j];
    		a[j] = t;
    	}
    }

在将字符串数组`a[]`排序时，根据它们的首字母进行三向切分，然后（递归地）将得到的三个子数组排序：一个含有所以首字母小于切分字符的字符串子数组，一个含有所以首字母等于切分字符串的子数组（排序时忽略它们的首字母），一个含有所有首字母大于切分字符的字符串的子数组。

--------------------

参考资料：《算法》第四版