排序的一些方法，需要代码！

package com.itheima; /* 请列举您了解的一些排序算法，并用Java语言实现一个效率较高的。         * 我了解的一些排序算法：      * 直接选择排序，冒泡排序，折半排序，快速排序，直接插入排序，希尔排序，归并排序      *       * 这里实现一个效率较高的冒泡排序*/ public class Test4 {                    public static void main(String[] args) {                          int[] str = {2,45,6,87,3,56,1,56};             //打印数组元素             printArray(str);             //对数组进行排序             bubbleSort(str);             printArray(str);                   } //数组打印     public static void printArray(int[] str) {                          System.out.print("[");             for (int i = 0; i < str.length; i++) {                     if(i!=str.length-1)                             System.out.print(str[i]+",");                     else                             System.out.println(str[i]+"]");                                  }     } //冒泡排序     public static void bubbleSort(int[] str) {              for ( int i = 0; i < str.length; i++ )             {                 for ( int j = i + 1; j < str.length; j++ )                 {                     if (str[i] > str[j])                     {                         swap(str, i, j);                     }                 }             }                               } //元素交换位置     public static void swap(int[] str, int i, int j) {             int temp = str[i];             str[i] = str[j];             str[j] = temp;     }  }

import java.util.Scanner;  /*编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表）  例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，截取3个字节也要是"HM"而不要出现半个中文*/   public class Test10 {       public static void main(String[] args) throws Exception {           // 输入要截取的字符串               Scanner scanner =new Scanner(System.in);                 String a;                 int i;                 System.out.println("请输入一个字符串和截取字节数：");                 a=scanner.nextLine();                                  i=scanner.nextInt();         System.out.println(mySubstring(a,i));       }             public static String mySubstring(String s, int length) throws Exception {           // 获取一个字符占两个字节的Unicode的编码格式的字节数组           byte[] bytes = s.getBytes("Unicode");   /*  String的getBytes()方法是得到一个系统默认的编码格式的字节数组  中文是用unicode进行编码的  于是在接收和发送的时候，都必须进行bytes的转换  */           // 表示当前的字节数           int n = 0;           // 要截取的字节数，从第3个字节开始           int i = 2;           for (; i < bytes.length && n < length; i++) {                     // 奇数位置，如3、5、7等，为UCS2编码中两个字节的第二个字节               if (i % 2 == 1)                   n++; // 在UCS2第二个字节时n加1               else {                   // 当UCS2编码的第一个字节不等于0时，该UCS2字符为汉字，一个汉字算两个字节                   if (bytes[i] != 0) {                       n++;                   }               }           }           // 如果i为奇数时，处理成偶数                 if (i % 2 == 1) {               // 该UCS2字符是汉字时，去掉这个截一半的汉字               if (bytes[i - 1] != 0)                   i = i - 1;               // 该UCS2字符是字母或数字，则保留该字符               else                   i = i + 1;           }           return new String(bytes, 0, i, "Unicode");       }   }  

不错，又长见识了

学习 学习

//选择排序
public static void Demo(int[] arr) {
                for (int x=0;x<arr.length-1 ; x++) {
                        for (int y=x+1;y<arr.length ; y++) {
                                if (arr[x]>arr[y]) {
                                        swap(arr,x,y);
                                }
                        }
                }
        }
//冒泡排序
public static void Demo2(int[] arr){
                for (int x=0;x<arr.length-1 ;x++ ){
                        for (int y=0;y<arr.length-x-1 ;y++ ){
                                if (arr[y]>arr[y+1]) {
                                        swap(arr,y,y+1);
                                }
                        }
                }
        }

还没学到- -   表示不太懂

学习中。。

1选择排序 *                  int[] arr = {66,55,44,33,22,11};                 原理：如果拿0角标上的元素依次和后面的元素进行比较，                       第一次内循环结束后，最小值出现在了0角标位置。                 arr[0]与arr[1-5]比了五次                 arr[1]与arr[2-5]比了四次                 arr[2]与arr[3-5]比了三次                 arr[3]与arr[4-5]比了二次                 arr[4]与arr[5]比了一次                 你就想想我们是如何打星星                 *****                 ****                 ***                 **                 *                 arr[x]与arr[y]比较                 数组长度是6                 for (int x = 0;x < arr.length - 1;x++){                         for (int y = x + 1;y < arr.length;y++){                                 if (arr[x] > arr[y]){                                         int temp = arr[x];                                         arr[x] = arr[y];                                         arr[y] = temp;                                 }                         }                 }                  * 2冒泡排序                  int[] arr = {66,55,44,33,22,11};                 原理：两个相邻元素进行比较，第一次比较完以后，最大值出现在了最大角标处。                 第一次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4],arr[4]与arr[5],比了五次                 第二次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3],arr[3]与arr[4]比了四次                 第三次:arr[0]与arr[1],arr[1]与arr[2],arr[2]与arr[3]比了三次                 第四次:arr[0]与arr[1],arr[1]与arr[2]比了二次                 第五次:arr[0]与arr[1]比了一次                 for (int x = 0;x < arr.length - 1; x++){                         //-1防止角标越界                         //-x为了提高效率                         for (int y = 0;y < arr.length - 1 - x;y++){//6                                 if (arr[y] > arr[y+1]){                                         int temp = arr[y];                                         arr[y] = arr[y+1];                                         arr[y+1] = temp;                                 }                         }                 } * 3,查找         * A：无序数组         *                                           int[] arr = {33,22,11,44,55,66};                         public static int getIndex(int[] arr,int key) {                                 for (int x = 0;x < arr.length;x++){                                         if (key == arr[x]){                                                 return x;                                         }                                 }                                 return -1;                         }         * B：有序数组 二分查找         *                          数组长度是6,最大角标值是5                         public static int getIndex(int[] arr,int key) {                                 int min = 0;                                 int max = arr.length-1;                                 int mid = (min + max)/2;                                 while (key != arr[mid]){                                         if (key > arr[mid]){                                                 min = mid + 1;                                         }else if (key < arr[mid]){                                                 max = mid - 1;                                         }                                         if (min > max){                                                 return -1;                                         }                                         mid = (min + max)/2;                                 }                                 return mid;                                                          }

这篇博客里面讲的很详细了 http://blog.csdn.net/hguisu/article/details/7776068

/**  
* 冒泡法排序<br/>  

* <li>比较相邻的元素。如果第一个比第二个大，就交换他们两个。</li>  
* <li>对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。</li>  
* <li>针对所有的元素重复以上的步骤，除了最后一个。</li>  
* <li>持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。</li>  

*   
* @param numbers  
*            需要排序的整型数组  
*/  
public static void bubbleSort(int[] numbers) {   
    int temp; // 记录临时中间值   
    int size = numbers.length; // 数组大小   
    for (int i = 0; i < size - 1; i++) {   
        for (int j = i + 1; j < size; j++) {   
            if (numbers[i] < numbers[j]) { // 交换两数的位置   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
            }   
        }   
    }   
}  

**  
* 选择排序<br/>  
* <li>在未排序序列中找到最小元素，存放到排序序列的起始位置</li>  
* <li>再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。</li>  
* <li>以此类推，直到所有元素均排序完毕。</li>  

*   
* @param numbers  
*/  
public static void selectSort(int[] numbers) {   
    int size = numbers.length, temp;   
    for (int i = 0; i < size; i++) {   
        int k = i;   
        for (int j = size - 1; j >i; j--)  {   
            if (numbers[j] < numbers[k])  k = j;   
        }   
        temp = numbers[i];   
        numbers[i] = numbers[k];   
        numbers[k] = temp;   
    }   
}  

建议你掌握冒泡排序和选择排序，可以背写出来，但是一般写代码的时候排序，都用的是Arrays(需要导包)里面的的sort排序方法，它的底层是一个快速排序，原理有点复杂，会用就行，很方便，可以将任意数组排序，比如arr是一个int数组，就可以直接排序:Arrays.sort(arr)，这样就排序完毕了，想看效果，遍历即可。我用的手机回复的 ，不方便写完整的代码，你如果觉得对你有帮助，可以扣1，我上电脑打代码给你

public class ArrayDemo6{
        public static void main(String args[]){
                int[] arr = {1,4,23,0,67,4,78};
                printArray(arr);
                Arraysort(arr);
                printArray(arr);
               
        }
        public static void printArray(int[] arr){
                System.out.print("[");
                for(int i=0;i<arr.length;i++){
                        if(i!=arr.length-1){
                                System.out.print(arr[i]+", ");
                        }
                        else
                                System.out.print(arr[i]+"]");
                }
        }
        public static void Arraysort(int[] arr){
                for(int i=0;i<arr.length-1;i++){        //{1，2，3，4，5，6，9，7，5，4，3}
                        for(int j=i+1;j<arr.length;j++){
                                if(arr[i]<arr[j]){
                                        int temp;
                                        temp = arr[j];
                                        arr[j] = arr[i];
                                        arr[i] = temp;
                                }
                        }
                }
        }
}

一、排序主要分为：简单基础排序和快速排序。
1.简单基础排序：冒牌排序，插入排序等。
2.快速排序：快速排序，堆排序，基数排序，shell排序等。
二、排序实现代码分为C语言和Java语言，来进行实现。市场或者是大学数据结构书籍都是用的是C语言进行举例的，所以不清楚版主想用那种语言实现。如果实在不行可以去当当网买一本Java算法分析或者Java数据结构都有对排序进行详细的讲解。希望对题主有意义。

二叉树排序：package ye;

public class Ye_erchashu {
        public static class BinaryNode {  
                 
                    private int value;//current value  
                    private BinaryNode lChild;//left child  
                    private BinaryNode rChild;//right child  
                     
                    public BinaryNode(int value, BinaryNode l, BinaryNode r){  
                        this.value = value;  
                        this.lChild = l;  
                        this.rChild = r;  
                    }  
                     
                    public BinaryNode getLChild() {  
                        return lChild;  
                    }  
                    public void setLChild(BinaryNode child) {  
                        lChild = child;  
                    }  
                    public BinaryNode getRChild() {  
                        return rChild;  
                    }  
                    public void setRChild(BinaryNode child) {  
                        rChild = child;  
                    }  
                    public int getValue() {  
                        return value;  
                    }  
                    public void setValue(int value) {  
                        this.value = value;  
                    }  
                     
                    //iterate all node.  
                    public static void iterate(BinaryNode root){  
                        if(root.lChild!=null){  
                            iterate(root.getLChild());  
                        }  
                        System.out.print(root.getValue() + " ");  
                        if(root.rChild!=null){  
                            iterate(root.getRChild());  
                        }  
                    }  
                     
                    /**
                     * add child to the current node to construct a tree.
                     * Time: O( nlog(n) )
                     * **/  
                    public void addChild(int n){  
                        if(n<value){  
                            if(lChild!=null){  
                                lChild.addChild(n);  
                            }  
                            else{  
                                lChild = new BinaryNode(n, null, null);  
                            }  
                        }  
                        else{  
                            if(rChild!=null){  
                                rChild.addChild(n);  
                            }  
                            else{  
                                rChild = new BinaryNode(n, null, null);  
                            }  
                        }  
                    }  
                     
                    //test case.  
                    public static void main(String[] args){  
                        System.out.println();  
                        int[] arr = new int[]{23,54,1,65,9,3,100};  
                        BinaryNode root = new BinaryNode(arr[0], null, null);  
                        for(int i=1; i<arr.length; i++){  
                            root.addChild(arr[i]);  
                        }  
                        BinaryNode.iterate(root);  
                    }  
                }
}

来观看观看，学习下

插入排序 1.直接插入排序 原理：将数组分为无序区和有序区两个区，然后不断将无序区的第一个元素按大小顺序插入到有序区中去，最终将所有无序区元素都移动到有序区完成排序。 要点：设立哨兵，作为临时存储和判断数组边界之用。 实现： Void InsertSort(Node L[],int length) { Int i,j;//分别为有序区和无序区指针 for(i=1;i<length;i++)//逐步扩大有序区 { j=i+1; if(L[j]<L[i]) { L[0]=L[j];//存储待排序元素 While(L[0]<L[i])//查找在有序区中的插入位置，同时移动元素 { L[i+1]=L[i];//移动 i--;//查找 } L[i+1]=L[0];//将元素插入 } i=j-1;//还原有序区指针 } } 2.希尔排序 原理：又称增量缩小排序。先将序列按增量划分为元素个数相同的若干组，使用直接插入排序法进行排序，然后不断缩小增量直至为1，最后使用直接插入排序完成排序。 要点：增量的选择以及排序最终以1为增量进行排序结束。 实现： Void shellSort(Node L[],int d) { While(d>=1)//直到增量缩小为1 { Shell(L,d); d=d/2;//缩小增量 } } Void Shell(Node L[],int d) { Int i,j; For(i=d+1;i<length;i++) { if(L[i]<L[i-d]) { L[0]=L[i]; j=i-d; While(j>0&&L[j]>L[0]) { L[j+d]=L[j];//移动 j=j-d;//查找 } L[j+d]=L[0]; } } } 交换排序 1.冒泡排序 原理：将序列划分为无序和有序区，不断通过交换较大元素至无序区尾完成排序。 要点：设计交换判断条件，提前结束以排好序的序列循环。 实现： Void BubbleSort(Node L[]) { Int i ,j; Bool ischanged;//设计跳出条件 For(j=n;j<0;j--) { ischanged =false; For(i=0;i<j;i++) { If(L[i]>L[i+1])//如果发现较重元素就向后移动 { Int temp=L[i]; L[i]=L[i+1]; L[i+1]=temp; Ischanged =true; } } If(!ischanged)//若没有移动则说明序列已经有序，直接跳出 Break; } } 2.快速排序 原理：不断寻找一个序列的中点，然后对中点左右的序列递归的进行排序，直至全部序列排序完成，使用了分治的思想。 要点：递归、分治 实现：  选择排序 1.直接选择排序 原理：将序列划分为无序和有序区，寻找无序区中的最小值和无序区的首元素交换，有序区扩大一个，循环最终完成全部排序。 要点： 实现： Void SelectSort(Node L[]) { Int i,j,k;//分别为有序区，无序区，无序区最小元素指针 For(i=0;i<length;i++) { k=i; For(j=i+1;j<length;j++) { If(L[j]<L[k]) k=j; } If(k!=i)//若发现最小元素，则移动到有序区 { Int temp=L[k]; L[k]=L[i]; L[i]=L[temp]; }   } } 2.堆排序 原理：利用大根堆或小根堆思想，首先建立堆，然后将堆首与堆尾交换，堆尾之后为有序区。 要点：建堆、交换、调整堆 实现： Void HeapSort(Node L[]) { BuildingHeap(L);//建堆（大根堆） For(int i=n;i>0;i--)//交换 { Int temp=L[i]; L[i]=L[0]; L[0]=temp; Heapify(L,0,i);//调整堆 } }  Void BuildingHeap(Node L[]) { For(i=length/2 -1;i>0;i--) Heapify(L,i,length); } 归并排序 原理：将原序列划分为有序的两个序列，然后利用归并算法进行合并，合并之后即为有序序列。 要点：归并、分治 实现： Void MergeSort(Node L[],int m,int n) { Int k; If(m<n) { K=(m+n)/2; MergeSort(L,m,k); MergeSort(L,k+1,n); Merge(L,m,k,n); } }  基数排序 原理：将数字按位数划分出n个关键字，每次针对一个关键字进行排序，然后针对排序后的序列进行下一个关键字的排序，循环至所有关键字都使用过则排序完成。 要点：对关键字的选取，元素分配收集。 实现： Void RadixSort(Node L[],length,maxradix) { Int m,n,k,lsp; k=1;m=1; Int temp[10][length-1]; Empty(temp); //清空临时空间 While(k<maxradix) //遍历所有关键字 { For(int i=0;i<length;i++) //分配过程 { If(L[i]<m) Temp[0][n]=L[i]; Else Lsp=(L[i]/m)%10; //确定关键字 Temp[lsp][n]=L[i]; n++; } CollectElement(L,Temp); //收集 n=0; m=m*10; k++; } }

学习学习

选择排序（直接排序） ： 使用数组中的一个元素与其他位置的元素挨个比较一次，符合条件交换位置。

for(int j = 0 ; j<arr.length-1 ; j++ ){
                        //把最大值放在第0号位置
                        for(int i = j+1 ; i<arr.length ; i++){
                                if(arr[j]<arr){
                                        int temp = arr[j];
                                        arr[j] = arr;        
                                        arr = temp;
                                }
                        }
  }冒泡排序： 相邻的两个元素比较一次，符合条件交换 位置。
for(int j = 0 ; j<arr.length-1; j++){ // 疑问：arr.length-1。　因为五个数据只需要找出四个最大值即可排序
                        //把最大值放在倒数的第一个位置
                        for(int i = 0 ;  i < arr.length-1 - j ; i++){  //i=4  疑问： 因为for循环每执行完一次就 可以找出一个最大值，每找出一个最大值其实就可以少比较一次。
                                if(arr>arr[i+1]){
                                        //交换位置
                                        int temp  = arr;
                                        arr = arr[i+1];
                                        arr[i+1] = temp;
                                }
                        }
}

来学习一下,

/**
     * 直接选择排序
     */
    private static void directChooseSort ( int[] array )
    {
        for ( int i = 0; i < array.length; i++ )
        {
            int index = i;
            for ( int j = i + 1; j < array.length; j++ )
            {
                if (array[index] > array[j])
                {
                    index = j;
                }
            }
            if (i != index)
            {
                int temp = array[i];
                array[i] = array[index];
                array[index] = temp;
            }
        }
    }

    /**
     * 堆排序
     */
    private static void heapSort ( int[] array, int start, int len )
    {
        int pos = ( len - 1 ) / 2;
        for ( int i = pos; i >= 0; i-- )
        {
            int tmp = array[start + i];
            int index = i * 2 + 1;
            while (index < len)
            {
                if (index + 1 < len && array[start + index] < array[start + index + 1]) // 从小到大
                {
                    index += 1;
                }
                if (tmp < array[start + index]) // 从小到大
                {
                    array[start + i] = array[start + index];
                    i = index;
                    index = i * 2 + 1;
                }
                else
                {
                    break;
                }
            }
            array[start + i] = tmp;
        }
        for ( int i = 0; i < len; i++ )
        {
            int temp = array[start];
            array[start] = array[start + len - 1 - i];
            array[start + len - 1 - i] = temp;
            // 再一次
            int post = 0;
            int tmp = array[start + post];
            int index = 2 * post + 1;
            while (index < len - 1 - i)
            {
                if (index + 1 < len - 1 - i && array[start + index] < array[start + index + 1]) // 从小到大
                {
                    index += 1;
                }
                if (tmp < array[start + index]) // 从小到大
                {
                    array[start + post] = array[start + index];
                    post = index;
                    index = post * 2 + 1;
                }
                else
                {
                    break;
                }
            }
            array[start + post] = tmp;
        }
    }

    /**
     * 冒泡排序
     */
    private static void bubbleSort ( int[] array )
    {
        for ( int i = 0; i < array.length; i++ )
        {
            for ( int j = i + 1; j < array.length; j++ )
            {
                if (array[i] > array[j])
                {
                    int temp = array[i];
                    array[i] = array[j];
                    array[j] = temp;
                }
            }
        }
    }

    /**
     * 快速排序
     */
    private static void quickSort ( int[] array, int start, int end )
    {
        if (start < end)
        {
            int key = array[start];
            int i = start;
            for ( int j = start + 1; j < end + 1; j++ )
            {
                if (key > array[j])
                {
                    int temp = array[j];
                    array[j] = array[i + 1];
                    array[i + 1] = temp;
                    i++;
                }
            }
            array[start] = array[i];
            array[i] = key;
            quickSort (array, start, i - 1);
            quickSort (array, i + 1, end);
        }
    }