Joiike's Blog

智客日记–专注于中文的现代化和国际化

2017年10月19日
发表者 foengz
暂无评论

Python3 程序流程控制

有时我们会希望程序根据不同情况作出不同的反应,例如按照当前的时间分别打印出“早上好”或“上午好”、“晚上好”等等。这时候就需要使用控制流程语句了。python3 拥有3种此类语句,分别为if,for和while。

下面我们通过编程来了解这些语句:

从“开始”菜单→“所有程序”→“Python 3.5”→“IDLE(Python 3.5 32-bit)” 启动IDLE。从“File”菜单中选择“New File”菜单项,打开一个 IDLE 编辑器窗口。在出现的窗口中输入下面的代码(注意:Python3对缩进有严格要求,每一级都有4个空格):

代码写完并保存后,按F5键即可运行我们的新程序了。

再新建一个文件,试试下面的代码(测试while循环):

import random
secret=random.randint(1,100)
running=True
print("这是一个简单的猜数游戏!")
print("你要猜的是一个1-99之间的整数,你只有6次机会哦!\n ")
while running:
    guess=int(input("请输入你猜的数字: "))    #提示玩家输入
    if guess == secret:
        print("恭喜! 你猜对了!!! ")
        running=False    #这将导致while 循环终止。
    elif guess < secret:
        print("====你猜的数字太小!====\n")
        
                                                                                                                                                                
    else:
        print("====你猜的数字太大!!====\n")
else:
        print("游戏结束了!欢迎下次再玩!!!")

 

再新建一个文件,试试下面的代码(测试for循环):

for i in range(1,6):
    print('加油!'*i)
else:
    print("\n for循环结束.")

说明:range返回一个开始于第一个数字而结束于第二个数的序列,\n 换行回车,print(‘加油!’*i) 连续打印 i 个’加油’。

2017年10月19日
发表者 foengz
暂无评论

Python3 基本数据类型之 列表(List)

数据与数据之间往往存在着某种关联,例如我们的个人信息都包括姓名、身份证号码、电话号码、职业,email等。因此需要用到某种数据结构来组织这些数据。Python3 中拥有4种内建数据结构 – 列表,元组(tuple),字典和集合。

列表是最常用的Python3 数据类型,它用一个方括号内的若干用逗号分隔的数据项的形式表示,例如:

list1=[‘张三’,’李四’,’王五’,’刘六’]

list2=[‘张三’,’18808880888′,’教师’,’xxx@163.com’]

list3=[[‘张三’,’教师’,’xxx@163.com’],[‘李四’,’学生’,’yyy@163.com’]]

启动IDLE(可以从“开始”菜单→“所有程序”→“Python 3.5”→“IDLE(Python 3.5 32-bit)”来启动IDLE),在IDLE的交互式窗口(Shell)中参照下图输入一些脚本并观察结果:

说明:1、list1[0],a[1],a[2]……分别表示变量 list1 中存储的字符串的第1,第2,第3……个数据项。

2、列表中的数据项也可以是列表(多维列表) 。

3、列表中的数据项可以被修改。

4、列表中的数据项可以被删除(del),我们还可以使用append()方法来添加列表项:

list1.append([‘朱八’])

list1.append([‘蔡九’])

2017年10月19日
发表者 foengz
暂无评论

Python3 基本数据类型之 String(字符串)

String(字符串)是最常用的数据类型之一,尤其是在自然语言处理和Web编程领域。

一、了解 String(字符串)数据类型

Python3 对字符串的处理提供了非常优秀的支持,这也是我要自学 Python3 的主要原因之一。

Python3 中,字符串是以Unicode编码的,也就是说,Python3 的字符串对包括中文在内的世界各国的文字都能很好地支持。

启动IDLE(可以从“开始”菜单→“所有程序”→“Python 3.5”→“IDLE(Python 3.5 32-bit)”来启动IDLE),在IDLE的交互式窗口(Shell)中参照下图输入一些脚本并观察结果:

说明:1、a[0],a[1],a[2]……分别表示变量 a 中存储的字符串的第1,第2,第3……个字符。

2、a[-1],a[-2],a[-3]……分别表示变量 a 中存储的字符串的倒数第1,倒数第2,倒数第3……个字符 。

3、a[0:7] 表示变量 a 中存储的字符串的第1至第7个字符(不包括a[7]),a[-5:-1]表示变量 a 中存储的字符串的倒数第5至倒数第2个字符(不包括a[-1])

4、a[:7] 表示变量 a 中存储的字符串的前7个字符,a[-5:] 表示变量 a 中存储的字符串的后5个字符。

5、赋值语句 b=”Pyhton”+”3″  表示将两个字符串连接起来并赋值给变量 b,字符串需放在英文的单引号或双引号之间,字符串不能与数字直接相 +

二、了解 ANSI、ASCII、Unicode 和 UTF-8 编码

早期的计算机采用1个字节(8个二进制位)处理字符(ASCII),因此最多只能处理28个字符,显然不方便处理世界各国的文字。随着计算机在各国的普及,用于处理世界各国文字的统一码 Unicode 发展起来了。

Unicode 采用两个或多个字节对字符进行编码(绝大多数字符是两个字节,包括英文、数字)。

UTF-8 是对 Unicode 的灵活运用。 UTF-8 的特点是对不同范围的字符使用不同长度的编码。对于0x00-0x7F之间的字符,UTF-8编码与ASCII编码完全相同,即只需 1 个字节即可,但对我们的汉字不利,每个汉字则最少也要 3 个字节。

ANSI 主要为Windows操作系统所用,也是采用的不同长度的编码,且不同的国家和地区的标准不同。在简体中文Windows操作系统中,ANSI 编码代表 GBK 编码;在繁体中文Windows操作系统中,ANSI编码代表Big5;在日文Windows操作系统中,ANSI 编码代表 Shift_JIS 编码。由于不同 ANSI 编码之间互不兼容,当信息在国际间交流时,无法将属于两种语言的文字,存储在同一段 ANSI 编码的文本中。对于中文操作系统而言,ANSI 编码表示英文字符时用一个字节,表示中文用两个或四个字节。

ANSI、ASCII、Unicode 和 UTF-8 编码对照表(用16进制表示):

2017年10月19日
发表者 foengz
暂无评论

Python3 基本数据类型之 Numbers(数字)

数据以及对数据的操纵乃一切程序的根本。

Python3 中有六个标准的数据类型,它们分别是:

  • Numbers(数字)
  • String(字符串)
  • List(列表)
  • Tuple(元组)
  • Sets(集合)
  • Dictionaries(字典)

一、了解 Numbers(数字)数据类型

Python3 对数字型数据的支持不仅有 int(整数)、float(浮点数),它还支持 bool(布尔)、complex(复数)。下面我们一起来体验体验。

启动IDLE(可以从“开始”菜单→“所有程序”→“Python 3.5”→“IDLE(Python 3.5 32-bit)”来启动IDLE),在IDLE的交互式窗口(Shell)中参照下图输入一些脚本并观察结果:

说明:1、Python3 中除了 +  –  *  / , 还有 **(乘方) //(除后取整)%(除后取余)等运算符。

2、Python3 中 Bool  用 True 表示“真”,False 表示“假”,分别等于数值 1 和 0 。

3、用运算符将数据联接起来得到的式子叫表达式。Python3  交互式环境中可直接计算表达式的值并输出,相当于非常高级的计算器。

二、变量

有时我们需要临时保存数据,因此变量是必不可少的。

Python3 中的变量不需要声明。但每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

变量的赋值需使用符号 “=”(赋值符),如:

a=3

b=2

或者同时给多个变量赋值:

a, b =3, 2

再次在IDLE的交互式窗口(Shell)中参照下图输入一些脚本并观察结果:

2017年10月19日
发表者 foengz
暂无评论

Python3 函数

1、调用函数

在前面的两节中我们已经调用过一些函数。如:abs(),pow(),chr(),print(),random.randint()等。其中

print() –打印函数

abs() –绝对值函数

chr() –字符函数

等等都是内置函数,随时可以直接调用。更多的内置函数请参阅:Built-in Functions

random.randint() 则是 random 模块中的函数,调用前必须先导入 random 模块(用 import random 语句导入)

关于random 模块的详情请参阅: random — Generate pseudo-random numbers

当然,我们也可以编写和使用我们自己定义的函数以满足我们独特的需求。

2、创建函数

下面我们创建一个简单的根据二代身份证号码获取生日的函数。

从“开始”菜单→“所有程序”→“Python 3.5”→“IDLE(Python 3.5 32-bit)” 启动IDLE。从“File”菜单中选择“New File”菜单项,打开一个 IDLE 编辑器窗口。在出现的窗口中输入下面的代码(注意格式:有些行前面有4个空格,有些没有):


#定义 birth() 函数:
def birth(str):
    id=str
    id_birth=id[6:14]    #取出身份证号码的第7-14位
    year=id_birth[0:4]
    moon=id_birth[4:6]
    day=id_birth[6:8]
    print("生日: "+year+'年'+moon+'月'+day+'日')

#调用 birth() 函数:
str1=input('请输入二代身份证号码: ')
birth(str1)

代码写完并保存后,按F5键即可运行我们的新程序了。

免责声明:本文仅代表作者个人观点,著作权归作者所有。其原创性以及文中陈述文字和内容(包括图片、视频、附件等)未经本站证实,对本文以及其中全部或者部分内容、文字的真实性、完整性、及时性本站不作任何保证或承诺,请用户仅作参考,并请自行核实相关内容。转载作品务请注明出处,机构云平台、个人云空间的建设权、管理权、所有权均归实名机构和实名师生所有,与世界大学城无关。

2017年10月19日
发表者 foengz
暂无评论

利用 Python3 编写“猜数游戏”

1. 安装和试用 Python3 一节中我们学会了怎样在 Python 的交互式环境中使用 Python 3,但我们在 Python 的交互式环境中输入的代码将无法保存。作为初学者的我们使用 Python 自带的 IDLE 是一个不错的选择。

IDLE 是 Python 软件包自带的一个集成开发环境,我们可以利用它方便地创建、运行、测试和调试 Python3 程序。

安装Python后,我们可以从“开始”菜单→“所有程序”→“Python 3.5”→“IDLE(Python 3.5 32-bit)”来启动IDLE。IDLE启动后的初始窗口下图所示:

下面我们利用IDLE的来编写我们的“猜数游戏”:

1、从“File”菜单中选择“New File”菜单项,打开一个 IDLE 编辑器窗口。

2、在出现的窗口中输入下面的代码:

import random
secret=random.randint(1,100)
guess=0
tries=0
print("这是一个简单的猜数游戏!")
print("你要猜的是一个1-99之间的整数,你只有6次机会哦!\n ")
while guess != secret and tries < 6:
    guess=int(input("请输入你猜的数字: "))    #提示玩家输入
    if guess < secret:
        print("====你猜的数字太小!====\n")
        
                                                                                                                                                                
    elif guess > secret:
        print("====你猜的数字太大!!====\n")
    tries=tries+1
    
if guess == secret:
        print("恭喜! 你猜对了!!! ")
else:
        print("这次没机会了!祝你下次好运!!!")
        print("正确的数字是",secret)

代码写完并保存后,按F5键即可运行我们的“猜数游戏”程序了。

2017年10月19日
发表者 foengz
暂无评论

安装和试用 Python3

一、安装  Python3

要开始学习 Python 编程,首先得安装 Python。

Python 有两个版本,一个是2.x版,一个是3.x版,目前的最新版本是 Python3.5.2。

可点击下面的链接下载 Python3.5.2(32位操作系统请下载32位),然后运行下载的安装包:

Python3.5.2(32位)下载

Python3.5.2(64位)下载

注意:在安装过程中一定要勾选 Add Python 3.5 to PATH,然后点 “Customize installation” ,两次点击“Next” ,然后修改安装路径为C:\Python3 , 再点击“Install”,即可顺利完成 Python3  的定制安装。

安装成功后,打开命令提示符窗口(  CTR L  与  ALT 中间的 WINDOWS 键+R 键,会出现一个运行窗口,在里面输入 CMD,回车就能打开命令窗口.),敲入py,你将看到提示符>>>,这就表示我们已经在 Python 交互式环境中了,可以输入任何Python代码(如  print(‘大家好!’*3)  ),回车后会立刻得到执行结果。输入exit()并回车,就可以退出Python交互式环境。

二、试用  Python3

再次敲入 py 进入 Python3 交互式环境中。在Python提示符 >>> 后依次输入下面的代码:

print('试用 Python3 的内置函数:')
abs(-520)
abs(-3.14)
pow(2,63)
pow(2,3,5)
chr(65)
chr(97); chr(98); chr(99)
len('么么哒')
len(“Chinese intellectuals are writing treatises on the grass-mud horse's social importance.”)

2017年10月19日
发表者 foengz
暂无评论

Python3 简介

最近想学习中文信息化处理,而 Python 语言无疑是进行这一工作的首选,为此我打算从零开始学习 Python 语言。况且,学好了 Python 语言,以后到我的空间发表文章,上传资源,获取资源等等,甚至于股票的量化交易都可以让计算机来自动完成,何乐而不为呢?

现在,全世界有几百种编程语言,但流行的编程语言也就十几种。根据TIOBE的统计,最新的排名顺序(截至2016年5月)为:

排在前面的几种都比较难学,Python 不仅容易学习,而且为我们提供了丰富且完善的基础代码库,覆盖了网络、文件、GUI、数据库、文本等大量内容。用 Python 开发,许多功能不必从零编写,直接使用现成的代码库即可。

十多年的计算机课程教学实践告诉我,边教学边学习最能促进学习的进步。因此,在我们的教学中鼓励学生互学互教应该是一种非常有效的教学方法,而这正是PI教学法(同伴教学法)的精髓。

因此,我打算将自己学习 Python 的过程以所谓“教程”的方式写出来,一方面是为了督促自己的学习,同时也为有类似需求的朋友提供某种参考,欢迎朋友们和我一起学习,一起讨论,共同提高。

2013年11月1日
发表者 foengz
2条评论

Java中ArrayList类的用法

Java中ArrayList类的用法(转)

1、什么是ArrayList
ArrayList就是传说中的动态数组,用MSDN中的说法,就是Array的复杂版本,它提供了如下一些好处:
动态的增加和减少元素
实现了ICollection和IList接口
灵活的设置数组的大小

2、如何使用ArrayList
最简单的例子:
ArrayList list = new ArrayList();
for( int i=0;i <10;i++ ) //给数组增加10个Int元素
list.add(i);
//..程序做一些处理
list.remove(5);//将第6个元素移除
for( int i=0;i <3;i++ ) //再增加3个元素
list.add(i+20);

3、ArrayList和LinkedList的大致区别:

1.ArrayList是实现了基于动态数组的数据结构,LinkedList基于链表的数据结构。
2.对于随机访问get和set,ArrayList觉得优于LinkedList,因为LinkedList要移动指针。
3.对于新增和删除操作add和remove,LinedList比较占优势,因为ArrayList要移动数据。

ArrayList和LinkedList是两个集合类,用于存储一系列的对象引用(references)。例如我们可以用ArrayList来存储一系列的String或者Integer。那么ArrayList和LinkedList在性能上有什么差别呢?什么时候应该用ArrayList什么时候又该用LinkedList呢?
一.时间复杂度
首先一点关键的是,ArrayList的内部实现是基于基础的对象数组的,因此,它使用get方法访问列表中的任意一个元素时(random access),它的速度要比LinkedList快。LinkedList中的get方法是按照顺序从列表的一端开始检查,直到另外一端。对LinkedList而言,访问列表中的某个指定元素没有更快的方法了。
假设我们有一个很大的列表,它里面的元素已经排好序了,这个列表可能是ArrayList类型的也可能是LinkedList类型的,现在我们对这个列表来进行二分查找(binary search),比较列表是ArrayList和LinkedList时的查询速度,看下面的程序:

Java代码  收藏代码
  1. package com.mangocity.test;
  2. import java.util.LinkedList;
  3. import java.util.List;
  4. import java.util.Random;
  5. import java.util.ArrayList;
  6. import java.util.Arrays;
  7. import java.util.Collections;
  8. public class TestList …{
  9.      public static final int N=50000;
  10.      public static List values;
  11.      static…{
  12.          Integer vals[]=new Integer[N];
  13.          Random r=new Random();
  14.          for(int i=0,currval=0;i<N;i++)…{
  15.              vals=new Integer(currval);
  16.              currval+=r.nextInt(100)+1;
  17.          }
  18.          values=Arrays.asList(vals);
  19.      }
  20.      static long timeList(List lst)…{
  21.          long start=System.currentTimeMillis();
  22.          for(int i=0;i<N;i++)…{
  23.              int index=Collections.binarySearch(lst, values.get(i));
  24.              if(index!=i)
  25.                  System.out.println(“***错误***”);
  26.          }
  27.          return System.currentTimeMillis()-start;
  28.      }
  29.      public static void main(String args[])…{
  30.          System.out.println(“ArrayList消耗时间:”+timeList(new ArrayList(values)));
  31.          System.out.println(“LinkedList消耗时间:”+timeList(new LinkedList(values)));
  32.      }
  33. }

我得到的输出是:ArrayList消耗时间:15
LinkedList消耗时间:2596
这个结果不是固定的,但是基本上ArrayList的时间要明显小于LinkedList的时间。因此在这种情况下不宜用LinkedList。二分查找法使用的随机访问(random access)策略,而LinkedList是不支持快速的随机访问的。对一个LinkedList做随机访问所消耗的时间与这个list的大小是成比例的。而相应的,在ArrayList中进行随机访问所消耗的时间是固定的。
这是否表明ArrayList总是比LinkedList性能要好呢?这并不一定,在某些情况下LinkedList的表现要优于ArrayList,有些算法在LinkedList中实现时效率更高。比方说,利用Collections.reverse方法对列表进行反转时,其性能就要好些。
看这样一个例子,加入我们有一个列表,要对其进行大量的插入和删除操作,在这种情况下LinkedList就是一个较好的选择。请看如下一个极端的例子,我们重复的在一个列表的开端插入一个元素:

Java代码  收藏代码
  1. package com.mangocity.test;
  2. import java.util.*;
  3. public class ListDemo {
  4.      static final int N=50000;
  5.      static long timeList(List list){
  6.      long start=System.currentTimeMillis();
  7.      Object o = new Object();
  8.      for(int i=0;i<N;i++)
  9.          list.add(0, o);
  10.      return System.currentTimeMillis()-start;
  11.      }
  12.      public static void main(String[] args) {
  13.          System.out.println(“ArrayList耗时:”+timeList(new ArrayList()));
  14.          System.out.println(“LinkedList耗时:”+timeList(new LinkedList()));
  15.      }
  16. }

这时我的输出结果是:ArrayList耗时:2463
LinkedList耗时:15
这和前面一个例子的结果截然相反,当一个元素被加到ArrayList的最开端时,所有已经存在的元素都会后移,这就意味着数据移动和复制上的开销。相反的,将一个元素加到LinkedList的最开端只是简单的未这个元素分配一个记录,然后调整两个连接。在LinkedList的开端增加一个元素的开销是固定的,而在ArrayList的开端增加一个元素的开销是与ArrayList的大小成比例的。
二.空间复杂度
在LinkedList中有一个私有的内部类,定义如下:

Java代码  收藏代码
  1. private static class Entry {
  2.          Object element;
  3.          Entry next;
  4.          Entry previous;
  5.      }

每个Entry对象reference列表中的一个元素,同时还有在LinkedList中它的上一个元素和下一个元素。一个有1000个元素的LinkedList对象将有1000个链接在一起的Entry对象,每个对象都对应于列表中的一个元素。这样的话,在一个LinkedList结构中将有一个很大的空间开销,因为它要存储这1000个Entity对象的相关信息。
ArrayList使用一个内置的数组来存储元素,这个数组的起始容量是10.当数组需要增长时,新的容量按如下公式获得:新容量=(旧容量*3)/2+1,也就是说每一次容量大概会增长50%。这就意味着,如果你有一个包含大量元素的ArrayList对象,那么最终将有很大的空间会被浪费掉,这个浪费是由ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素,数组将不得不被重新进行分配以便能够增加新的元素。对数组进行重新分配,将会导致性能急剧下降。如果我们知道一个ArrayList将会有多少个元素,我们可以通过构造方法来指定容量。我们还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。
三.总结
ArrayList和LinkedList在性能上各有优缺点,都有各自所适用的地方,总的说来可以描述如下:
1.对ArrayList和LinkedList而言,在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言,主要是在内部数组中增加一项,指向所添加的元素,偶尔可能会导致对数组重新进行分配;而对LinkedList而言,这个开销是统一的,分配一个内部Entry对象。
2.在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动;而在LinkedList的中间插入或删除一个元素的开销是固定的。
3.LinkedList不支持高效的随机元素访问。
4.ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间
可以这样说:当操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能;当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。

2013年10月30日
发表者 foengz
9条评论

java数组排序

import java.util.Random;

/**
* 排序测试类
*
* 排序算法的分类如下:
* 1.插入排序(直接插入排序、折半插入排序、希尔排序);
* 2.交换排序(冒泡泡排序、快速排序);
* 3.选择排序(直接选择排序、堆排序);
* 4.归并排序;
* 5.基数排序。
*
* 关于排序方法的选择:
* (1)若n较小(如n≤50),可采用直接插入或直接选择排序。
*  当记录规模较小时,直接插入排序较好;否则因为直接选择移动的记录数少于直接插人,应选直接选择排序为宜。
* (2)若文件初始状态基本有序(指正序),则应选用直接插人、冒泡或随机的快速排序为宜;
* (3)若n较大,则应采用时间复杂度为O(nlgn)的排序方法:快速排序、堆排序或归并排序。
*
* @author WangRuifeng
*/
public class SortTest {

/**
* 初始化测试数组的方法
* @return 一个初始化好的数组
*/
public int[] createArray() {
Random random = new Random();
int[] array = new int[10];
for (int i = 0; i < 10; i++) {
array[i] = random.nextInt(100) – random.nextInt(100);//生成两个随机数相减,保证生成的数中有负数
}
System.out.println(“==========原始序列==========”);
printArray(array);
return array;
}

/**
* 打印数组中的元素到控制台
* @param source
*/
public void printArray(int[] source) {
for (int i : source) {
System.out.print(i + ” “);
}
System.out.println();
}

/**
* 交换数组中指定的两元素的位置
* @param source
* @param x
* @param y
*/
private void swap(int[] source, int x, int y) {
int temp = source[x];
source[x] = source[y];
source[y] = temp;
}

/**
* 冒泡排序—-交换排序的一种
* 方法:相邻两元素进行比较,如有需要则进行交换,每完成一次循环就将最大元素排在最后(如从小到大排序),下一次循环是将其他的数进行类似操作。
* 性能:比较次数O(n^2),n^2/2;交换次数O(n^2),n^2/4
*
* @param source 要排序的数组
* @param sortType 排序类型
* @return
*/
public void bubbleSort(int[] source, String sortType) {
if (sortType.equals(“asc”)) { //正排序,从小排到大
for (int i = source.length – 1; i > 0; i–) {
for (int j = 0; j < i; j++) {
if (source[j] > source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else if (sortType.equals(“desc”)) { //倒排序,从大排到小
for (int i = source.length – 1; i > 0; i–) {
for (int j = 0; j < i; j++) {
if (source[j] < source[j + 1]) {
swap(source, j, j + 1);
}
}
}
} else {
System.out.println(“您输入的排序类型错误!”);
}
printArray(source);//输出冒泡排序后的数组值
}

/**
* 直接选择排序法—-选择排序的一种
* 方法:每一趟从待排序的数据元素中选出最小(或最大)的一个元素, 顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
* 性能:比较次数O(n^2),n^2/2
* 交换次数O(n),n
* 交换次数比冒泡排序少多了,由于交换所需CPU时间比比较所需的CUP时间多,所以选择排序比冒泡排序快。
* 但是N比较大时,比较所需的CPU时间占主要地位,所以这时的性能和冒泡排序差不太多,但毫无疑问肯定要快些。
*
* @param source 要排序的数组
* @param sortType 排序类型
* @return
*/
public void selectSort(int[] source, String sortType) {

if (sortType.equals(“asc”)) { //正排序,从小排到大
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] > source[j]) {
swap(source, i, j);
}
}
}
} else if (sortType.equals(“desc”)) { //倒排序,从大排到小
for (int i = 0; i < source.length; i++) {
for (int j = i + 1; j < source.length; j++) {
if (source[i] < source[j]) {
swap(source, i, j);
}
}
}
} else {
System.out.println(“您输入的排序类型错误!”);
}
printArray(source);//输出直接选择排序后的数组值
}

/**
* 插入排序
* 方法:将一个记录插入到已排好序的有序表(有可能是空表)中,从而得到一个新的记录数增1的有序表。
* 性能:比较次数O(n^2),n^2/4
* 复制次数O(n),n^2/4
* 比较次数是前两者的一般,而复制所需的CPU时间较交换少,所以性能上比冒泡排序提高一倍多,而比选择排序也要快。
*
* @param source 要排序的数组
* @param sortType 排序类型
*/
public void insertSort(int[] source, String sortType) {
if (sortType.equals(“asc”)) { //正排序,从小排到大
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] < source[j – 1]); j–) {
swap(source, j, j – 1);
}
}
} else if (sortType.equals(“desc”)) { //倒排序,从大排到小
for (int i = 1; i < source.length; i++) {
for (int j = i; (j > 0) && (source[j] > source[j – 1]); j–) {
swap(source, j, j – 1);
}
}
} else {
System.out.println(“您输入的排序类型错误!”);
}
printArray(source);//输出插入排序后的数组值
}

/**
* 反转数组的方法
* @param source 源数组
*/
public void reverse(int[] source) {

int length = source.length;
int temp = 0;//临时变量

for (int i = 0; i < length / 2; i++) {
temp = source[i];
source[i] = source[length – 1 – i];
source[length – 1 – i] = temp;
}
printArray(source);//输出到转后数组的值
}

/**
* 快速排序
* 快速排序使用分治法(Divide and conquer)策略来把一个序列(list)分为两个子序列(sub-lists)。
* 步骤为:
* 1. 从数列中挑出一个元素,称为 “基准”(pivot),
* 2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,该基准是它的最后位置。这个称为分割(partition)操作。
* 3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。
* 递回的最底部情形,是数列的大小是零或一,也就是永远都已经被排序好了。虽然一直递回下去,但是这个算法总会结束,因为在每次的迭代(iteration)中,它至少会把一个元素摆到它最后的位置去。
* @param source 待排序的数组
* @param low
* @param high
* @see SortTest#qsort(int[], int, int)
* @see SortTest#qsort_desc(int[], int, int)
*/
public void quickSort(int[] source, String sortType) {
if (sortType.equals(“asc”)) { //正排序,从小排到大
qsort_asc(source, 0, source.length – 1);
} else if (sortType.equals(“desc”)) { //倒排序,从大排到小
qsort_desc(source, 0, source.length – 1);
} else {
System.out.println(“您输入的排序类型错误!”);
}
}

/**
* 快速排序的具体实现,排正序
* @param source
* @param low
* @param high
*/
private void qsort_asc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //这个条件用来结束递归
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] > x) {
j–; //从右向左找第一个小于x的数
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] < x) {
i++; //从左向右找第一个大于x的数
}
if (i < j) {
source[j] = source[i];
j–;
}
}
source[i] = x;
qsort_asc(source, low, i – 1);
qsort_asc(source, i + 1, high);
}
}

/**
* 快速排序的具体实现,排倒序
* @param source
* @param low
* @param high
*/
private void qsort_desc(int source[], int low, int high) {
int i, j, x;
if (low < high) { //这个条件用来结束递归
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] < x) {
j–; //从右向左找第一个小于x的数
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] > x) {
i++; //从左向右找第一个大于x的数
}
if (i < j) {
source[j] = source[i];
j–;
}
}
source[i] = x;
qsort_desc(source, low, i – 1);
qsort_desc(source, i + 1, high);
}
}

/**
* 二分法查找
* 查找线性表必须是有序列表
*
* @param source
* @param key
* @return
*/
public int binarySearch(int[] source, int key) {
int low = 0, high = source.length – 1, mid;
while (low <= high) {
mid = (low + high) >>> 1; //相当于mid = (low + high) / 2,但是效率会高些
if (key == source[mid]) {
return mid;
} else if (key < source[mid]) {
high = mid – 1;
} else {
low = mid + 1;
}
}
return -1;
}

public static void main(String[] args) {
SortTest sortTest = new SortTest();

int[] array = sortTest.createArray();

System.out.println(“==========冒泡排序后(正序)==========”);
sortTest.bubbleSort(array, “asc”);
System.out.println(“==========冒泡排序后(倒序)==========”);
sortTest.bubbleSort(array, “desc”);

array = sortTest.createArray();

System.out.println(“==========倒转数组后==========”);
sortTest.reverse(array);

array = sortTest.createArray();

System.out.println(“==========选择排序后(正序)==========”);
sortTest.selectSort(array, “asc”);
System.out.println(“==========选择排序后(倒序)==========”);
sortTest.selectSort(array, “desc”);

array = sortTest.createArray();

System.out.println(“==========插入排序后(正序)==========”);
sortTest.insertSort(array, “asc”);
System.out.println(“==========插入排序后(倒序)==========”);
sortTest.insertSort(array, “desc”);

array = sortTest.createArray();
System.out.println(“==========快速排序后(正序)==========”);
sortTest.quickSort(array, “asc”);
sortTest.printArray(array);
System.out.println(“==========快速排序后(倒序)==========”);
sortTest.quickSort(array, “desc”);
sortTest.printArray(array);

System.out.println(“==========数组二分查找==========”);
System.out.println(“您要找的数在第” + sortTest.binarySearch(array, 74) + “个位子。(下标从0计算)”);
}
}

字符串排序:

public class StringSort {
public static void main(String []args) {
String[] s={“a”,”b”,”c”,”d”,”m”,”f”};
for(int i=s.length-1;i>=1;i–){
for(int j=0;j<=i-1;j++) {
if(s[j].compareTo(s[j+1])<0) {
String temp=null;
temp=s[j];
s[j]=s[j+1];
s[j+1]=temp;
}
}
}
for(String a:s){
System.out.print(a+” “);
}
}
}
比较字符串的实质是比较字符串的字母,首字母相同,比较下一个,然后又相同的话,再下一个….所以你可以先用substring();截出第一个字符,然后再比较,相同的再截第二个,…..