黑马程序员技术交流社区

标题: day05JAVA笔记 [打印本页]

---

作者: 仙兒哥    时间: 2013-4-10 02:19
标题: day05JAVA笔记
.关于数组的操作练习
       
        1.排序*

                选择排序(开发)
                       
                        用数组中左边元素与右边所有元素依次比较，如果满足条件，进行交接，
                        最值出现在左边。

                        代码实现
                        public static void selectSort(int[] arr){
                                //对数组进行排序
                                for(int i=0;i<arr.length-1;i++){
                                //控制数组中的每一个元素下标，要比较的那个元素符号                                       
                                        for(int j=i+1;j<arr.length;j++){
                                        //操作与i元素比较的所有元素下标                                               
                                                if(arr[i]<arr[j]){
                                                        int tmp=arr[i];
                                                        arr[i]=arr[j];
                                                        arr[j]=tmp;
                                                }
                                               

                                        }
                                }

                        }
                        改进代码
                        public static void selectSort1(int[] arr){
                                //对数组进行排序
                                for(int i=0;i<arr.length-1;i++){
                                       
                                        for(int j=i+1;j<arr.length;j++){
                                               
                                                swap(arr,i,j);
                                               

                                        }
                                }

                        }
                        //将指定的两个值进行交换
                        /*
                                参数:int[] arr要操作的数组   int i,int j这是数组中两个元素交换的元素的下标。
                        */
                        public static void swap(int[] arr,int i,int j){

                                if(arr[i]>arr[j]){
                                        int tmp=arr[i];
                                        arr[i]=arr[j];
                                        arr[j]=tmp;
                                }
                        }
                       
                //选择排序的优化
                       
                public static void selectSort(int[] arr){               
                       
                        //对数组进行排序
                        for(int i=0;i<arr.length-1;i++){
                               
                                int index=i; //用来记录最值的下标
                               
                                for(int j=i+1;j<arr.length;j++){
                                       
                                        if(arr[index]>arr[j]){
                                                index=j; //让index一直记录的是最值的下标.
                                        }
                                }
                                //将i位置上的元素与index位置上的元素进行交换
                                if(index!=i){ //如果当前要交接的元素的值正好在应该存在的位置，那么不需要进行交换
                                        int tmp=arr[i];
                                        arr[i]=arr[index];
                                        arr[index]=tmp;
                                }
                        }

                }

                       
                冒泡排序(笔试)
                原理:相邻的两个元素依次进行比较，当所有元素比较一次后，产生的最值就出现在数组的最右边
                     下次在将其它的元素进行比较，最值出现在比较的这些元素的最右边。所有的元素全都比较完成
                         后数组中的元素就排序。
                         //冒泡排序
                public static void bubbleSort(int[] arr){
                       
                        for(int i=0;i<arr.length;i++){ //只是控制比较的次数
               
                                for(int j=0;j<arr.length-1-i;j++){  //-1目的是为了控制越界  -i：为了控制最右边的最值不在参与比较。
                                       
                                        if(arr[j]>arr[j+1]){ //相邻元素进行比较

                                                //两个元素进行交换。       
                                                int tmp=arr[j];
                                                arr[j]=arr[j+1];
                                                arr[j+1]=tmp;
                                        }
                                }
                        }
                }
               
               

       
        2.查找

                1.普通查找：比较简单，可以应用在任意数组
               
                /*
                        功能:查找数组中是否存在指定元素,如果存在返回其下标
                        参数: 1.数组   2.要查找的元素
                        返回值: 查找到的元素的下标,如果返回-1,代表没有查找到指定的元素

                */
                public static int search(int[] arr,int key){
                       
                        for(int i=0;i<arr.length;i++){
                       
                                if(arr[i]==key){
                                       
                                        return i;
                                }       
                        }

                        //没找到返回什么
                        return -1;
                }

                       
                       

                2.二分法(折半)查找 只能应用有顺序的数组中。
                原理:需要定义 start=0 end=数组的下标最大值(数组名.length-1) middle=(start+end)/2
                     用要查找的值与middle位置上的元素进行比较，
                     如果大于  start=middle+1
                     如果小于  end=middle-1
                     等于      中了，找到了这个值
                     middle每次操作后都应该重新计算 middle=(start+end)/2

                    当start>end的值代表找不到这个值了，这时候就不需要查找了


                /*
                功能;通过折半查找指定元素
                参数：int[] arr 它必须是有顺序的  int key 要查找的元素符号
                返回值:如果key在数组中存在，那么返回其下标，不存在返回-1

                */
                public static int halfSearch(int[] arr,int key){
                       
                        int start=0; // 开始
                        int end=arr.length-1; //结束
                        int middle=(start+end)/2; //中间

                        while(start<=end){ //如果开始的值一下直小于或等于结束值那么说明元素还没有查找完成。
                               
                                if(key>arr[middle]){//要查找的元素大于中间位置元素，那么开始就应该变化的成middle+1，从这个位置在查找
                                        start=middle+1;       
                                }else if(key<arr[middle]){ //要查找的元素小于中间元素，那么结束就应该成middle-1,这个位置就是新的结束位置

                                        end=middle-1;       
                                }else if(key==arr[middle]){//如果等于，那么代表查找到了。
                                        return middle;
                                }
                                 middle=(start+end)/2;        //每一次变化后，middle必须重新计算               
                        }

                        return -1;

                }


       
        3.反转
                原理:定义开始为0与结束为数组长度-1,变量来操作数组的下标
                     将开始与结束的位置元素进行交换，
                         然后让开始++,结束执行--,在进行交换.

                直到开始下标值大于或等于于结束的下标的值，不在进行交换。

                public static void reverseArray(int[] arr){
                       
                        //start 代表的是开始
                        //end 代表的是结束.

                        for(int start=0,end=arr.length-1;start<end;start++,end--){

                                int tmp=arr[start];
                                arr[start]=arr[end];
                                arr[end]=tmp;
                        }       
                }

               

        4.查表应用
               
                主要是完成进制转换.
                十进制----->2,8,16

                        使用查表法对进制转换进行改良

        查表示例
        现在数组arr中的元素值与tools数组中的元素值对应，当我们得到arr数组的元素0时，我们就可以显示tools数组中下标为0元素
        ,就得到了周日.

        int[] arr={0,1,2,3,4,5,6};

        String[] tools={"周日","周一","周二","周三","周四","周五","周六"};

        什么时候使用查表法

                当我们操作的数组与另一个表中的数组有一一对应关系，这个时候就可以使用查表法.

        class Demo9
        {
                public static void main(String[] args)
                {
                        String s1=toBinary(10);

                        System.out.println(s1);

                        String s2=toOctal(10);

                        System.out.println(s2);

                        String s3=toHex(10);

                        System.out.println(s3);
               
                }

                //使用位运算符进行十进制转换成二进制。
                /*
                        参数：要转换的十进制数
                        返回值:它的二进制表示形式
                */
                public static String toBinary(int n){
                       
                        return numberToString(n,1,1);
                }

                //使用位运算进行下进制转换成八进制
                public static String toOctal(int n){
                       
                        return numberToString(n,7,3);
                }

                //使用位运算进行下进制转换成十六进制
                public static String toHex(int n){
                       
                        return numberToString(n,15,4);
                }

                /*
                        该方法作用：将一个整数n,转换成对应的进制数
                        参数:n要转换的整数   num代表的是截取位 1 7 15  off 位移的偏移量
                */
                public static String numberToString(int n,int num,int off){
                        String str="";
                        String[] tools={"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};
                       
                        int[] arr=new int[32];
                       
                        int index=0;//
                       
                        for(;index<arr.length;index++){
                               
                                arr[index]=n&num;   //截取几位问题
                                n=n>>>off;  //右移几位问题
                               
                                if(n==0){
                                        break;
                                }
                        }
                       
                        for(int i=index;i>=0;i--){
                               
                                int number=arr[i];

                                str+=tools[number];


                        }
                        return str;
                }
        }





2.二维数组介绍

       

        数组本身是一种数组类型，它是引用类型。

        数组是容器可以装数据。数据可以是什么类型?
        数组中的元素可以是任何类型数据。数组中就可以装入数组.

       

---

作者: 仙兒哥    时间: 2013-4-10 02:19
int[] a=new int[10]; //数组

        int[][] arr={a}; //arr是一个数组，它里面装入了一个元素a

        二维数组的创建方式
       
        静态
                元素类型[][] 数组名={};
                元素类型[][] 数组名=new 元素类型[][]{};
        动态
                元素类型[][] 数组名=new 元素类型[长度][];       







一 数组的操作练习
1.1 选择排序 (开发常用)
什么是循环嵌套
        如果循环中又出现循环，叫循环嵌套，
        可以将里层的循环看成是外层的循环体，
        但是执行的流程，必须按照循环的流程执行
外层控制行,内层控制列
System.out.println()//代表输出一个换行
\n 换行
\t 制表符
\r 回车
\b 退格

需求:定义3个变量,对这3个变量进行排序

class Demo //之前学过的挨个比大小然后用变量存再调换
{
        public static void main(String[] args)
        {
                int a=3;
                int b=5;
                int c=1;

                if(a<b)//保证a是a,b中的最大值
                {
                        int tem=a;
                        a=b;
                        b=tmp
                }
                if(a<c)//保证a是a,c中的最大值
                {
                        int tem=a;
                        a=c;
                        c=tmp
                }
                if(b<c)//保证a是a,b中的最大值
                {
                        int tem=b;
                        b=c;
                        c=tmp
                }

                System.out.println(a+""+b+""+c);
        }
}

       
需求:用数组中左边元素与右边所有元素一次比较,如果满足条件进行交换,最值出现在左边,以此比较久得到从大到小
class Demo
{
        public static void main(String[] args)
        {
                int [] arr={2,3,634,34};                                //对这些数进行排序
                for (int i=0;i<arr.length-1;i++ )                //控制数组中的每一个元素下标,要比较的那个元素符号,-1是因为最后一个数肯定是最小的
                {
                        for (int j=i+1;j<arr.length;j++ )        //操作与i元素比较的所有元素下标
                        {
                                if (arr[i]<arr[j])
                                {
                                        int tmp=arr[i];
                                        arr[i]=arr[j];
                                        arr[j]=tmp;

                                        swap[int i,int j;]
                                }

                        }
                {
                        System.out.println(arr[0]);        "补充循环打印代码"
                        System.out.println(arr[1]);
                        System.out.println(arr[2]);
                        System.out.println(arr[3]);
                }
        }
}

选择排序练习2"补充代码和注释
//swap(arr,i,j)
//循环比较的方法,只能交换2个变量,数组元素没变
        //参数:int[] arr要操作的数据 int i,int j,这是数组中两个元素交换的元素的下标
public static void swap(int[],int i,int j)
        if(a>b)
        {
                int tmp=a;
                a=b;
                b=tmp;
        }

---

作者: 仙兒哥    时间: 2013-4-10 02:20
1.2 冒泡排序 (笔试题多)
排序效率
选择排序优化>冒泡>选择排序

                冒泡排序原理
                1.临近2个元素进行比较,如果满足条件进行交换
                2.一次比较完成后,最值出现在最右边,下次再进行比较时,最右就不参与比较
                3.最值已经出现在这些参与比较的元素的最右边

        "冒泡排序的优化arr.length-1-i"//-1的目的是为了控制越界,-i为了控制最右的最值不在参与比较
1.3 排序代码优化
选择排序的优化
        思想:1.选择排序是在堆内存中进行频繁的交换操作
                 2.堆内存效率低,想到效率高的栈内存
                 3.在栈内存中定义一个变量,让他记录一次比较时的最值的下标
                 4.完成后,将制定的下标的元素值进行交换
        "代码补充"
        "图看懂"//循环后的到的结果是什么?
1.4 数组查找
1.4.1 普通查找
        在容器中判断是否存在指定的元素,如果存在那将其所在的位置返回
        功能:查找数组中是否存在指定元素,如果存在返回其下标
        参数:1数组 2要查找的元素
        返回值:查找到的元素的下标,如果返回-1,代表没有查找到没有找到指定的元素
        public static void main(String[] args)
                int[] arr={3,4,1,2,7,8}
                int key=2;
                int indx=search(arr.key);

                if(index==-1)
                {
                        System.out.println(key+"在数组中不存在")
                }
                else
                {
                        System.out.println(key+"在地"+(index+1)+"位置")
                }

        public static int search(int[],int key)
        {
                for(int i=0;i<arr.length;i++)
                        if(arr[i]==key)
                        {
                                return i;
                        }
                return -1;//
        }
1.4.2 折半查找
折半查找(二分法查找)Demo6
        要求
                数组中的元素必须排序
        注意
                不能现将数组排序,再对其进行折半查找"看视频补充"
        原理
                设定三个值,分别代表开始=0,结束=arr.length-1,
                中间=(开始+结束)/2

                用key与中间位置上的元素进行比较,如果key大于中间元素
                开始=中间+1 结束不变
                如果key小于中间元素
                结束=中间-1
                中间位置上的元素如果与key相等,那么中了,返回middle即可

        功能:通过折半查找指定元素
        参数:int[] arr 它必须是有顺序的 int key要查找的元素符号
        返回值:如果key在数组中存在,那么返回其下标,不存在返回-1
1.4.3 折半查找另一种体现
1.5 反转
反转
        反转原理:       
                1.定义开始为0,结束为数组长度-1,变量才操作数组的下标
                2.将开始与结束的位置元素进行交换
                3.让开始++,结束执行--,在进行交换
                4.直到开始下标值值大于或等于结束的值//只写大于奇数个数时候就自己跟自己交换了
        反转步骤:
                1.让数组的开始位置元素与结束位置元素进行交换,有图)
                2.让开始位置++
                3.结束位置--
                4.什么时候结束交换
                        开始的值>=结束位置的值

二 查表法
2.1查表应用
主要是完成进制转换"Demo7必会哦 亲..."
2.2 什么时候用查表法
当我们操作的数据与另一个表中的数据有一一对应关系,这个时候就可以使用查表法

进制转换的最终版 Demo9(找工作之前能写出即可)

二 二维数组
2.1 二维数组的定义和内存图
二维数组介绍
二维数组是一个数组里面的元素又是一个数组
                       
二维数组的创建
                        静态
                                元素类型[][] 数组名={};
                                元素类型[][] 数组名=new 元素类型[][];                               
                        动态       
                                元素类型[][] 数组名=new 元素类型[长度][];

                                数组本身是一种数据类型,它是引用类型
                                数组是容器可以装数据,数据可以是什么类型?
                                数组中的元素可以是任何类型的数据
                                int[] a=new int[10];//数组
                                int[][] arr={a};        //arr是一个数组,它里面装入了一个元素a

       
怎样操作二维数组
        int leg=arr.length;        //得到数组的长度
        int n=arr[0];//这段代码有问题 =右边是arr[0]他的类型是一个一维数组,=左边是int变量

---

作者: 穆爱明    时间: 2013-7-9 09:09
学习一下，感谢分享！

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2