黑马程序员——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; 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 bubbleSort(int[] arr){
                for(int x=0; x<arr.length-1; x++){
                     //每次内循环定最大值在尾角标的位置。
                    for(int y=0; y<arr.length-x-1; y++) {  //-x:让每一次比较的元素减少，-1：避免角标越界。
                            if(arr[y]<arr[y+1])
                            swap(arr,y,y+1);
                    }
                }
        }
        /*
        发现无论什么排序。都需要对满足条件的元素进行位置置换。所以可以把这部分相同的代码提取出来，单独封装成一个函数。
        */
        public static void swap(int[] arr,int a,int b){
                    int temp = arr[a];
                    arr[a] = arr[b];
                    arr[b] = temp;
        }
        //打印数组 
        public static void printArray(int[] arr){
                    System.out.print("[");
                    for(int x=0; x<arr.length; x++){
                            if(x!=arr.length-1)
                                System.out.print(arr[x]+", ");
                            else
                                System.out.println(arr[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<arr.length; x++){
                                if(x!=arr.length-1)
                                        System.out.print(arr[x]+", ");
                                else
                                        System.out.println(arr[x]+"]");
                        }
            }
            //实现数组按升序排列的快速排序的方法。
            private static void quickSort(int[] arr) { 
                     if (arr.length > 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<arr.length; x++){
                        System.out.print(arr[x]);
                }
        }
}

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

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

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