黑马程序员——04Java各种排序方法和进制转换

------------ android培训 、 java培训 、期待与您交流！------------

1，选择排序和冒泡排序

import java.util.*;
public class SelectSort{ 
        public static void main(String[] args){
                int[] arr = {3,6,7,8,9,0,3};
                //排序前
                printArray(arr);
 
                //调用选择排序
                selectSort(arr);

                //调用冒泡排序
                bubbleSort(arr); 

                //javaAPI提供的排序方法
                Arrays.sort(arr);

                 //排序后：
                printArray(arr);
        } 
        //选择排序 
        public static void selectSort(int[] arr) {
                for (int x=0; xarr[y])
                                swap(arr,x,y);//置换
                        }
                }    
        }
 
        //冒泡排序
        public static void bubbleSort(int[] arr){
                for(int x=0; x

2，快速排序是对冒泡排序的一种改进，下面是快速排序的代码。
       

 	/ * 
        思路：
          1，对数组进行第一次排序，将其一分为二。
          2，对低端子数组和高端子数组分别进行递归排序。
          3，打印排序后的数组。 
         */
        public class QuickSort{
                public static void main(String[] args) {
                        //定义一个int数组。
                        int[] arr = new int[]{5,1,6,4,2,8,9};
                        //调用快速排序的方法，实现int数组按升序排列。
                        quickSort(arr);
                        //打印int数组。
                        printArray(arr);
                }
            //打印数组的方法。
            private static void printArray(int[] arr){
                        System.out.print("[");
                        for(int x=0; x 0) {//保证待排序的数组不为空
                            //调用方法subQuickSort();
                            subQuickSort(arr, 0, arr.length-1);
                    }
            }
            //利用递归思想，对数组进行快速排序。
            private static void subQuickSort(int[] arr, int low, int high) {
                    if (low < high) { 
                           //将数组一分为二  ,并返回中轴位置。
                            int middle = getMiddle(arr, low, high);
            
                            //对低端子数组进行递归排序  
                            subQuickSort(arr, low, middle-1); 
            
                            //对高端子数组进行递归排序  
                            subQuickSort(arr, middle + 1, high); 
                    }  
            }
            //定义方法实现将数组一分为二，并返回中轴的位置。
            private static int getMiddle(int[] arr, int low, int high) {  
                        //把数组的第一个元素作为中轴值。 
                        int temp = arr[low];
                        while (low < high) { 
                                while (low < high && arr[high] > temp)  
                                            high--;            
                                //比中轴值小的记录移到低端
                                arr[low] = arr[high];
            
                                while (low < high && arr[low] < temp) 
                                            low++;  
                                //比中轴值大的记录移到高端  
                                arr[high] = arr[low];   
                       } 
        
                        //将中轴值记录到low现在所在的位置。
                        arr[low] = temp;
        
                        //返回中轴的位置
                        return low;                     
            } 
}

3，进制转换 

class NumberTrans {
        public static void main(String[] args) {
                 //十进制转换为二进制 
                toBin(-6);
                //十进制转换为十六进制 
                toHex(-60);
                //十进制转换为八进制 
                toOct(60);
                 
                //javaAPI提供的方法 
                System.out.println(Integer.toBinaryString(6));
                System.out.println(Integer.toHexString(6));
        }
        //十进制-->二进制
        public static void toBin(int num){
                trans(num,1,1);
        }
        //十进制-->八进制
        public static void toOct(int num){
                trans(num,7,3);
        }
        //十进制-->十六进制
        public static void toHex(int num){
                trans(num,15,4);
        }
        public static void trans(int num,int base,int offset){
                if(num==0){
                    System.out.println(0);
                    return ;
                }
                char[] chs = {'0','1','2','3'
                                        ,'4','5','6','7'
                                        ,'8','9','A','B'
                                        ,'C','D','E','F'};
                char[] arr = new char[32];
                int pos = arr.length;
                while(num!=0){
                        int temp = num & base;//位运算
                        arr[--pos] = chs[temp];
                        num = num >>> offset;//无符号右移offset位
                }
                for(int x=pos; x

  此处重点掌握:
1,与位运算和无符号右移操作 的思想  .
2, 快速排序的递归思想.

------------ android培训 、 java培训 、期待与您交流 ！------------

详情请查看： http://edu.csdn.net/heima