package sort;
import java.util.Random;
public class Sort {
public static void main(String[] args){
Sort s=new Sort();
int[] array=s.createArray();
//冒泡排序
//正序 从小到大
System.out.println("========111.冒泡排序=======");
System.out.println("========冒泡排序后（正序）从小到大=======");
s.bubbleSort(array,"asc");
//倒叙 从大到小
System.out.println("========冒泡排序后（倒叙）从大到小=======");
s.bubbleSort(array,"desc");
//直接选择排序
System.out.println("\n====222直接选择排序=========");
System.out.println("====直接选择排序后（正序）从小到大=========");
s.directSelectSort(array, "asc");
System.out.println("====直接选择排序后（倒叙）从大到小=========");
s.directSelectSort(array, "desc");
//插入排序
System.out.println("\n====333插入排序=========");
System.out.println("====插入排序后（正序）从小到大=========");
s.insertSort(array, "asc");
System.out.println("====插入排序后（倒叙）从大到小=========");
s.insertSort(array, "desc");
//反转
//System.out.println("====原始数据反转=========");
//s.reverseok(array);
//快速排序
System.out.println("\n==========444快速排序==========");
System.out.println("==========快速排序后(正序)==========");
s.quickSort(array, "asc");
s.printArray(array);
System.out.println("==========快速排序后(倒序)==========");
s.quickSort(array, "desc");
s.printArray(array);
System.out.println("\n==========数组二分查找==========");
System.out.println("您要找的数在第" + s.binarySearch(array, -67)+ "个位子。（下标从0计算）");
}
//生成数据反转
public void reverseok(int[] data) {
int le=data.length;
int temp=0;
for (int i = 0; i < le/2; i++) {
temp=data[i];
data[i]=data[le-i-1];
data[le-i-1]=temp;
}
for (int i = 0; i < data.length; i++) {
System.out.print(data[i]+" ");
}
System.out.println();
}
//生成随机数组
public int[] createArray(){
Random random=new Random();
int[] arr=new int[10];
for(int i=1;i<10;i++){
arr[i]=random.nextInt(100)-random.nextInt(100);
}
System.out.println("===========原始序列=============");
printArray(arr);
return arr;
}
//打印随机数组
public void printArray(int[] data){
for(int i:data){
System.out.print(i+" ");
}
System.out.println();
}
// 交换数组中指定的两元素的位置
public void swap(int[] data,int x,int y){
int temp=data[x];
data[x]=data[y];
data[y]=temp;
}
//------------------------------------------------
// 11111111111111111111交换排序包括：冒泡排序，快速排序
//================================================
// 功能：冒泡排序
// 输入：数组名称（也就是数组首地址）、数组中元素个数
//====================================================
//算法思想简单描述：
//
// 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上
// 而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较
// 小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要
// 求相反时，就将它们互换。
//
// 下面是一种改进的冒泡算法，它记录了每一遍扫描后最后下沉数的
// 位置k，这样可以减少外层循环扫描的次数。
// ================================================
// 冒泡排序是稳定的。算法时间复杂度O(n2)--[n的平方]
//=====================================================
public void bubbleSort(int[] data,String sortType){
if(sortType.equals("asc")){//正排序，从小到大
//比较的轮数
//数组有多长，轮数就有多长
for(int i=1;i<data.length;i++){
//将相邻两个数进行比较，较大的数往后冒泡
for(int j=0;j<data.length-i;j++){
//每一轮下来会将比较的次数减少
if(data[j]>data[j+1]){
//交换相邻两个数
swap(data,j,j+1);
}
}
}
}
else if(sortType.equals("desc")){//倒排序，从大到小
//比较的轮数
for(int i=1;i<data.length;i++){
//将相邻的两个数进行比较，较大的数往后冒泡
for(int j=0;j<data.length-i;j++){
if(data[j]<data[j+1]){
swap(data,j,j+1);
}
}
}
}
else{
System.out.println("您输入的排序类型错误");
}
printArray(data);
}
//------------------------------------------------
//11111111111111111111交换排序包括：冒泡排序，快速排序
//================================================
//================================================
//功能：快速排序
//输入：数组名称（也就是数组首地址）、数组中起止元素的下标
//====================================================
//算法思想简单描述：
//
//快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟
//扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次
//扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只
//减少1。快速排序通过一趟扫描，就能确保某个数（以它为基准点吧）
//的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理
//它左右两边的数，直到基准点的左右只有一个元素为止。它是由
//C.A.R.Hoare于1962年提出的。
//
//显然快速排序可以用递归实现，当然也可以用栈化解递归实现。下面的
//函数是用递归实现的，有兴趣的朋友可以改成非递归的。
//=====================================================
//快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n2)
//=====================================================
//* 快速排序 快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。 步骤为：
//1. 从数列中挑出一个元素，称为 "基准"（pivot）， 2.
//重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分割之后，该基准是它的最后位置。这个称为分割（partition）操作。
//3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
//递回的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递回下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
public void quickSort(int[] data, String sortType) {
if (sortType.equals("asc")) { // 正排序，从小排到大
qsort_asc(data, 0, data.length - 1);
} else if (sortType.equals("desc")) { // 倒排序，从大排到小
qsort_desc(data, 0, data.length - 1);
} else {
System.out.println("您输入的排序类型错误！");
}
}
//快速排序的具体实现，排正序
private void qsort_asc(int data[], int low, int high) {
int i, j, x;
if (low < high) { // 这个条件用来结束递归
i = low;
j = high;
x = data[i];
while (i < j) {
while (i < j && data[j] > x) {
j--; // 从右向左找第一个小于x的数
}
if (i < j) {
data[i] = data[j];
i++;
}
while (i < j && data[i] < x) {
i++; // 从左向右找第一个大于x的数
}
if (i < j) {
data[j] = data[i];
j--;
}
}
data[i] = x;
qsort_asc(data, low, i - 1);
qsort_asc(data, i + 1, high);
}
}
//快速排序的具体实现，排倒序
private void qsort_desc(int data[], int low, int high) {
int i, j, x;
if (low < high) { // 这个条件用来结束递归
i = low;
j = high;
x = data[i];
while (i < j) {
while (i < j && data[j] < x) {
j--; // 从右向左找第一个小于x的数
}
if (i < j) {
data[i] = data[j];
i++;
}
while (i < j && data[i] > x) {
i++; // 从左向右找第一个大于x的数
}
if (i < j) {
data[j] = data[i];
j--;
}
}
data[i] = x;
qsort_desc(data, low, i - 1);
qsort_desc(data, i + 1, high);
}
}
//==========================================================================
//222222222222222222222222222选择排序包括 ： 直接选择排序法，堆排序
//==========================================================================
//直接选择排序法
//=====================================
/*
直接选择排序法----选择排序的一种 方法：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 性能：比较次数O(n^2),n^2/2 交换次数O(n),n
交换次数比冒泡排序少多了，由于交换所需CPU时间比比较所需的CUP时间多，所以选择排序比冒泡排序快。
但是N比较大时，比较所需的CPU时间占主要地位，所以这时的性能和冒泡排序差不太多，但毫无疑问肯定要快些。
*/
public void directSelectSort(int[] data,String sortType) {
if(sortType.equals("asc")){
int index;
for(int i=1;i<data.length;i++){
index=0;
for(int j=1;j<=data.length-i;j++){
if (data[j]>data[index]) {
index=j;
}
}
swap(data, data.length-i, index);
}
}
else if (sortType.equals("desc")) {
int index;
for (int i = 1; i < data.length; i++) {
index=0;
for (int j = 1; j < data.length-i; j++) {
if (data[j]<data[index]) {
index=j;
}
}
swap(data, data.length-i, index);
}
}
else {
System.out.println("您输入的排序类型不合法");
}
printArray(data);
}
//================================================
//功能：选择排序
//输入：数组名称（也就是数组的首地址），数组中元素的个数
//================================================
//算法思想描述：
// 在要排序的一组数中，选出最小的一个数与第一个位置的数交换，
// 然后在剩下的数当中再找最小的与第二个位置的数交换，
// 如此循环到倒数第二个数和最后一个数比较为止。
//================================================
//选择排序是不稳定的，算法复杂度为O(n2)---n的平方
public static int[] selectSort(int[] args){
//选择排序算法
for (int i=0;i<args.length-1 ;i++ ){
int min=i;
for (int j=i+1;j<args.length ;j++ ){
if (args[min]>args[j]){
min=j;
}
}
if (min!=i){
int temp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
return args;
}
//==========================================================================
//222222222222222222222222222选择排序包括 ： 直接选择排序法，堆排序
//==========================================================================
//
//
//================================================
// 功能：堆排序
// 输入：数组名称（也就是数组首地址）、数组中元素个数
//====================================================
//算法思想简单描述：
//
// 堆排序是一种树形选择排序，是对直接选择排序的有效改进。
// 堆的定义如下：具有n个元素的序列（h1,h2,...,hn),当且仅当
// 满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,...,n/2)
// 时称之为堆。在这里只讨论满足前者条件的堆。
//
// 由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项。完全二叉树可以
// 很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。
// 初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储顺序，
// 使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点
// 交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点
// 的堆，并对它们作交换，最后得到有n个节点的有序序列。
//
// 从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素
// 交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数
// 实现排序的函数。
//====================================================
// 堆排序是不稳定的。算法时间复杂度O(nlog2n)。
//
//*/
///*
// 功能：渗透建堆
// 输入：数组名称（也就是数组首地址）、参与建堆元素的个数、从第几个元素开始
//二分查找特定整数在整型数组中的位置(递归) 查找线性表必须是有序列表
public int binarySearch(int[] dataset, int data, int beginIndex,int endIndex) {
int midIndex = (beginIndex + endIndex) >>> 1; // 相当于mid = (low + high)
// / 2，但是效率会高些
if (data < dataset[beginIndex] || data > dataset[endIndex]
|| beginIndex > endIndex)
return -1;
if (data < dataset[midIndex]) {
return binarySearch(dataset, data, beginIndex, midIndex - 1);
} else if (data > dataset[midIndex]) {
return binarySearch(dataset, data, midIndex + 1, endIndex);
} else {
return midIndex;
}
}
// 二分查找特定整数在整型数组中的位置(非递归) 查找线性表必须是有序列表
public int binarySearch(int[] dataset, int data) {
int beginIndex = 0;
int endIndex = dataset.length - 1;
int midIndex = -1;
if (data < dataset[beginIndex] || data > dataset[endIndex]|| beginIndex > endIndex)
return -1;
while (beginIndex <= endIndex) {
midIndex = (beginIndex + endIndex) >>> 1; // 相当于midIndex =
// (beginIndex + endIndex) / 2，但是效率会高些
if (data < dataset[midIndex]) {
endIndex = midIndex - 1;
} else if (data > dataset[midIndex]) {
beginIndex = midIndex + 1;
} else {
return midIndex;
}
}
return -1;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//插入排序包括：直接插入排序，折半插入排序，希尔排序
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//插入排序
//方法：将一个记录插入到已排好序的有序表（有可能是空表）中,从而得到一个新的记录数增1的有序表。
//性能：比较次数O(n^2),n^2/4
//复制次数O(n),n^2/4
//比较次数是前两者的一般，而复制所需的CPU时间较交换少，所以性能上比冒泡排序提高一倍多，而比选择排序也要快。
public void insertSort(int[] data,String sortType) {
if (sortType.equals("asc")) {
for (int i = 1; i < data.length; i++) {
for (int j = 0; j < i; j++) {
if (data[j]>data[i]) {
swap(data, i, j);
}
}
}
}
else if(sortType.equals("desc")) {
for (int i = 1; i < data.length; i++) {
for (int j = 0; j < i; j++) {
if(data[j]<data[i]){
swap(data, i, j);
}
}
}
}
else {
System.out.println("您输入的数组不合法！");
}
printArray(data);
}
public static int[] insertSort(int[] args){
//插入排序算法 2
for(int i=1;i<args.length;i++){
for(int j=i;j>0;j--){
if (args[j]<args[j-1]){
int temp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}else break;
}
}
return args;
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//功能：直接插入排序
// 输入：数组名称（也就是数组首地址）、数组中元素个数
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//算法思想简单描述：
//
// 在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排
// 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
// 也是排好顺序的。如此反复循环，直到全部排好顺序。
//
// 直接插入排序是稳定的。算法时间复杂度O(n2)--[n的平方]
//=====================================================
//class Sort{
//
//}
/*
直接插入排序基本思想
1．直接插入排序的基本思想
直接插入排序（Straight Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。
把a[i]插入到a[0]，a[1]，...,a[i-1]之中的具体实施过程为:先把a[i]赋值给变量t,然后将t依次与a[i-1],a[i-2],...进行比较,将比t大的元素右移一个位置,直到发现某个j(0<=j<=i-1),使得a[j]<=t或j为(-1),把t赋值给a[j+1].
2、第i-1趟直接插入排序：
通常将一个记录R[i](i=2，3，…，n-1)插入到当前的有序区，使得插入后仍保证该区间里的记录是按关键字有序的操作称第i-1趟直接插入排序。
排序过程的某一中间时刻，R被划分成两个子区间R[1．．i-1]（已排好序的有序区）和R[i．．n]（当前未排序的部分，可称无序区）。
直接插入排序的基本操作是将当前无序区的第1个记录R[i]插人到有序区R[1．．i-1]中适当的位置上，使R[1．．i]变为新的有序区。因为这种方法每次使有序区增加1个记录，通常称增量法。
插入排序与打扑克时整理手上的牌非常类似。摸来的第1张牌无须整理，此后每次从桌上的牌(无序区)中摸最上面的1张并插入左手的牌(有序区)中正确的位置上。为了找到这个正确的位置，须自左向右(或自右向左)将摸来的牌与左手中已有的牌逐一比较。
一趟直接插入排序方法
1．简单方法
首先在当前有序区R[1..i-1]中查找R[i]的正确插入位置k(1≤k≤i-1)；然后将R[k．．i-1]中的记录均后移一个位置，腾出k位置上的空间插入R[i]。
注意：
若R[i]的关键字大于等于R[1．．i-1]中所有记录的关键字，则R[i]就是插入原位置。
2．改进的方法
一种查找比较操作和记录移动操作交替地进行的方法。
具体做法：
将待插入记录R[i]的关键字从右向左依次与有序区中记录R[j](j=i-1，i-2，…，1)的关键字进行比较：
① 若R[j]的关键字大于R[i]的关键字，则将R[j]后移一个位置；
②若R[j]的关键字小于或等于R[i]的关键字，则查找过程结束，j+1即为R[i]的插入位置。
关键字比R[i]的关键字大的记录均已后移，所以j+1的位置已经腾空，只要将R[i]直接插入此位置即可完成一趟直接插入排序。
直接插入排序算法
1．算法描述
实现程序
*/
void insert_sort(int a[],int n)
//待排序元素用一个数组a表示，数组有n个元素
{ int i,j;
int t;
for ( i=1; i<n; i++) //i表示插入次数，共进行n-1次插入
{ t=a[i]; //把待排序元素赋给t
j=i-1;
while ((j>=0)&& (t<a[j]))
{ a[j+1]=a[j]; j--; } // 顺序比较和移动
a[j+1]=t;}
}
/*
4、直接插入排序的效率分析
（1）时间复杂度
从时间分析，首先外层循环要进行n-1次插入，每次插入最少比较一次（正序），移动两次；最多比较i次，移动i＋2次（逆序）（i=1，2，…，n-1）。若分别用Cmin ，Cmax 和Cave表示元素的总比较次数的最小值、最大值和平均值，用Mmin ，Mmax 和Mave表示元素的总移动次数的最小值、最大值和平均值，则上述直接插入算法对应的这些量为：
Cmin=n-1 Mmin=2（n-1）
Cmax=1+2+…+n-1=（n2-n）/2 Mmax=3+4+…+n+1=（n2+3n-4）/2
Cave=（n2+n-2）/4 Mmax=（n2+7n-8）/4
因此，直接插入排序的时间复杂度为O（n2）。
由上面对时间复杂度的分析可知,当待排序元素已从小到大排好序(正序)或接近排好序时,所用的比较次数和移动次数较少;当待排序元素已从大到小排好序(逆序)或接近排好序时,所用的比较次数和移动次数较多,所以插入排序更适合于原始数据基本有序(正序)的情况.
插入法虽然在最坏情况下复杂性为O(n2)，但是对于小规模输入来说，插入排序法是一个快速的排序法。许多复杂的排序法，在规模较小的情况下，都使用插入排序法来进行排序，比如快速排序。
（2）空间复杂度
首先从空间来看，它只需要一个元素的辅助空间，用于元素的位置交换O(1)
（3）稳定性:
插入排序是稳定的,因为具有同一值的元素必然插在具有同一值得前一个元素的后面,即相对次序不变.
（4）结构的复杂性及适用情况
插入排序是一种简单的排序方法,他不仅适用于顺序存储结构(数组),而且适用于链接存储结构,不过在链接存储结构上进行直接插入排序时,不用移动元素的位置,而是修改相应的指针。
*/
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
// 功能：希尔排序
// 输入：数组名称（也就是数组首地址）、数组中元素个数
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//==================================================
//算法思想简单描述：
//
// 在直接插入排序算法中，每次插入一个数，使有序序列只增加1个节点，
// 并且对插入下一个数没有提供任何帮助。如果比较相隔较远距离（称为
// 增量）的数，使得数移动时能跨过多个元素，则进行一次比较就可能消除
// 多个元素交换。D.L.shell于1959年在以他名字命名的排序算法中实现
// 了这一思想。算法先将要排序的一组数按某个增量d分成若干组，每组中
// 记录的下标相差d.对每组中全部元素进行排序，然后再用一个较小的增量
// 对它进行，在每组中再进行排序。当增量减到1时，整个要排序的数被分成
// 一组，排序完成。
//
// 下面的函数是一个希尔排序算法的一个实现，初次取序列的一半为增量，
// 以后每次减半，直到增量为1。
//====================================================
// 希尔排序是不稳定的。
//=====================================================
//
//希尔排序(缩小增量法) 属于插入类排序,是将整个无序列分割成若干小的子序列分别进行插入排序。
//希尔排序并不稳定，O(1)的额外空间，时间复杂度为O(N*(logN)^2)。最坏的情况下的执行效率和在平均情况下的执行效率相比相差不多。
//基本思想：
//先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。
//所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；
//然后，取第二个增量d2<d1重复上述的分组和排序，
//直至所取的增量dt=1(dt<dt-l<…<d2<d1)，
//即所有记录放在同一组中进行直接插入排序为止。
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//折半插入排序
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//基数排序
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//_______________________________________________________________________
//归并排序
//______________________________________________________________________________
//_________________________________________________________________
//二路归并排序
//_____________________________________________________
//___________________________________________
//二叉树排序
//______________________________________________________
}
http://hi.baidu.com/gsgaoshuang/item/17a8ed3c24d9b1ba134b14c2
排序链接
http://sjjp.tjuci.edu.cn/sjjg/DataStructure/DS/web/paixu/paixu8.2.1.1.htm
