给定一个字符串String str=“aAbebBssE”,自己实现以个算法，输出字符串为“AaBbbEess”

[13兄]

给定一个字符串String str=“aAbebBssE”,自己实现以个算法，输出字符串为“AaBbbEess”；
谁给个答案。。。。

[苍蝇①号]

[Quote=引用 13 楼 zhaining522 的回复:]
Java codepackage number;import java.util.Arrays;import java.util.Collections;import java.util.List;publicclass number {/**
*@param args*/publicstaticvoid main(String[] args) {
String source="hbaBACDEFGHIJKabcdefghijklmnopqrLMNOPQRSTYVWSYZstsyz";byte [] by= source.getBytes();
ByteCompare [] bc=new ByteCompare[by.length];for(int i=0 ; i< by.length ; i++){
bc[i]=new ByteCompare(by[i]);
}
Arrays.sort(bc,Collections.reverseOrder());

System.out.println("by ="+ Arrays.toString(bc));
}

}class ByteCompareimplements Comparable {privatebyte a ;

ByteCompare(byte a ){this.a= a;
}publicbyte getByte(){returnthis.a;
}publicint compareTo(Object o) {byte b= ((ByteCompare)o).getByte();int re=0;if(a>96){//a为小写if(b>96){//b为小写 re= a<b?1:(a==b?0:-1);
}else{//b为大写 re= (a-32)<b?1:-1;
}
}else{//a为大写if(b>96){//b为小写 re= (a+32)<b?1:((a+32)==b?1:-1);
}else{//b为大写 re= a<b?1:(a==b?0:-1);
}
}return re;
}public String toString(){return String.valueOf((char)a);
}

}

引用thinking in java 中的一段话 “程序设计的基本目标是“将保持不变的事物与会发生改变的事物相分离”，而这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。因此，不是将进行比较的代码编写成为不同的子程序，而是使用回调技术（callback）。通过使用回调，可以将会发生变化的代码分离出来，然后由不会发生变化的代码回头调用会发生变化的代码。”
[/Quote]
哥们说的对。顶一个。
这方式常用，并不代表有用，效率低

[phyerbarte]

集思广意

package str;

import java.util.Arrays;

public class StringOrder {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String str ="FDSAJFWEIQsdfjslakdweijdskajkerwqEWERQdsafjfdsa";
		char[] strArray = str.toCharArray();
		Arrays.sort(strArray);

		int index = 0;
		for (int i = 0; i < strArray.length; i++) {
			for (int k = 0; k < strArray.length - 1; k++) {
				char indexC = strArray[i];
				if (indexC == strArray[k + 1]) {
					index = k+1;
				}

			}
			char currentChar = strArray[i];
			for (int j = 0; j < strArray.length; j++) {
				if (strArray[j] - 32 == currentChar) {
					str = new String(strArray);
					String stra = str.substring(0, index + 1);
					String strb = str.substring(index + 1, j);
					String strc = str.substring(j, j + 1);
					String strd = str.substring(j + 1, strArray.length);
					str = stra + strc + strb + strd;
					strArray = str.toCharArray();
				}
			}
		}
		System.out.println(str);
	}
}

[霜之哀伤]

对英文字母，char强转int就得到ASCII码了。

[angel6709]

string s="aAbebBssE";
            char[] ss=s.ToCharArray();

            Array.Sort(ss,new Comparer());
            MessageBox.Show(new String(ss));






class Comparer : IComparer<char> 
    {

    

        public int Compare(char x, char y)
        {
            return char.ToUpper(x).CompareTo(char.ToUpper(y));
        }


    }

[angel6709]

public int Compare(char x, char y)
{
return char.ToUpper(x).CompareTo(char.ToUpper(y));
}


--------------------->>>>>

public int Compare(char x, char y)
{
int ret= char.ToUpper(x).CompareTo(char.ToUpper(y));
if(ret==0)
{
ret= x.CompareTo(y);
}
return ret;
}

[angel6709]

楼主，不好意思，我用到的是C#。。。。。但思想是一样的哈。。。

[zhuzeitou]

import java.util.Arrays;
import java.util.Comparator;

class MyComparator implements Comparator {

	@Override
	public int compare(Object o1, Object o2) {
		if (o1 instanceof Character && o2 instanceof Character) {
			Character c1 = (Character) o1;
			Character c2 = (Character) o2;
			if (Character.toUpperCase(c1) == Character.toUpperCase(c2))
				return c1 - c2;
			return Character.toUpperCase(c1) - Character.toUpperCase(c2);
		}
		return 0;
	}

}

public class test {

	public static void main(String... args) {
		String str = "FDSAJFWEIQsdfjslakdweijdskajkerwqEWERQdsafjfdsa";
		char[] c1 = str.toCharArray();
		Character[] c = new Character[c1.length];
		for (int i = 0; i < c1.length; i++)
			c[i] = c1[i];
		Arrays.sort(c, new MyComparator());
		for (int i = 0; i < c1.length; i++)
			c1[i] = c[i];
		System.out.println(new String(c1));
	}
}

输出结果：
AaaaaDdddddEEEeeFFfffIiJjjjjkkklQQqRrSsssssWWww

[amdgaming]

什么 规律啊 总要 说说 吧。。。

[rye_grass]

对各个字符循环，比较，插入，
先不说算法效率好不好，单要实现不是很容易吗？

[phyerbarte]

package str;

public class StringUpDown {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String str="aAbebBssE";
		char[] strArray = null;
		for(int i=0;i<str.length();i++){
			strArray = str.toCharArray();
			strArray[i] = getReverseChar(strArray[i]);
			str = new String(strArray);
		}
		System.out.println(str);
	}

	private static char getReverseChar(char c) {
		if(Character.isLowerCase(c)){
			return Character.toUpperCase(c);
		}else{
			return Character.toLowerCase(c);
		}
	}
}

[phyerbarte]

哦，错了，以为是大小写转换。。

[叶涛网站推广优化]

貌似没学数据结构与算法？

[xiesisi3]

LZ的要求大概是，要进行字符串排序，首先是从a-z的排序，然后里面包含有大写在小写前面的排序。
这个从实现角度来说应该不难，但是关键是考虑效率问题吧。

[霜之哀伤]

就是按ASCII码排序嘛

[liu_liyang]

就是排序啊。按照字母的顺序排序。并且大写的放前面！

[psyuhen]

同LS。。。。

[13兄]

我也知道是大的字母放前面。。就像上面说的应该是根据ASCII码排序。。
可，怎么把字母转成ASCII码啊？

[xlxyeyu]

莫非这很难？
如果大于等于‘A’的，那么就减除32比较，如果此时等于了，那就比较实际值呗~~~~

[gao11811]

import java.util.*;

class bijiao 
{
	public static void main(String[] args) 
	{
		System.out.println(run("shkajyFskjhSDAKisjkSjkhsdHSAhjksASDhjklaa"));
	}

	public static StringBuffer run(String temp){
		char m[]=temp.toCharArray();
		Arrays.sort(m);		
		for(int y=0;y<m.length;y++){
			for(int z=0;z<m.length;z++){
				
				if (m[y]+32==m[z])
				{	
					while(m[y]==m[y+1]){
						y++;
					}
					char l=m[z];
						
						for(int w=z;w>y+1;w--){
							m[w]=m[w-1];
						}
						m[y+1]=l;
				}
			}
		}
		StringBuffer sb = new StringBuffer("");
		for(int x =0;x<m.length;x++){
			sb.append(m[x]);
		}
		return sb;
	}
}

---------- java run ----------
AAAaaaDDdFHhhhhhKkkkkkkSSSSsssssijjjjjjly

输出完成 (耗时 1 秒) - 正常终止

[zhaining522]

package number;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class number {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String source = "hbaBACDEFGHIJKabcdefghijklmnopqrLMNOPQRSTYVWSYZstsyz";
		byte [] by = source.getBytes();
		ByteCompare [] bc = new ByteCompare[by.length];
		for(int i = 0 ; i< by.length ; i ++){
			bc[i] = new ByteCompare(by[i]);
		}
		Arrays.sort(bc,Collections.reverseOrder());
		
		System.out.println("by = " + Arrays.toString(bc));
	}

}

class ByteCompare implements Comparable {
	
	private byte a ;
	
	ByteCompare(byte a ){
		this.a = a; 
	}
	
	public byte getByte(){
		return this.a;
	}
	
	public int compareTo(Object o) {
		byte b = ((ByteCompare)o).getByte();
		int re = 0;
		if(a>96){  //a为小写
			if(b>96){  //b为小写
				re = a<b?1:(a==b?0:-1);
			}else{	   //b为大写
				re = (a-32)<b?1:-1;
			}
		}else{	//a为大写
			if(b>96){  //b为小写
				re = (a+32)<b?1:((a+32)==b?1:-1);
			}else{	   //b为大写
				re = a<b?1:(a==b?0:-1);
			}
		}
		return re;
	}
	
	public String toString(){
		return String.valueOf((char)a);
	}
	
}

引用thinking in java 中的一段话 “程序设计的基本目标是“将保持不变的事物与会发生改变的事物相分离”，而这里，不变的是通用的排序算法，变化的是各种对象相互比较的方式。因此，不是将进行比较的代码编写成为不同的子程序，而是使用回调技术（callback）。通过使用回调，可以将会发生变化的代码分离出来，然后由不会发生变化的代码回头调用会发生变化的代码。”