Java中一维数组的常见操作

Java中一维数组的常见操作

---

操作数组最基础的思想：遍历

---

• 1.获取最值
• 2.选择排序
• 3.冒泡排序
• 4.折半查找
• 5.查表思想

---

1.获取最大值、最小值

通过遍历对数组中的每一元素进行比较，用变量记录较大或较小的值

1.获取最值代码

//获取最大值
Public static int getMax(int arr)
{
/.定变量记录较大的值；
Int max=arr[0];//初始化数组中的任意个元素；
//对数组进行遍历比较
For(int x=1;x<arr.length;x++)
{
If(arr[x]>max)
Max=arr[x];
}
Return max;
}
//同样有另外一种方式获取最大值
Public static int getMax(int[] arr)
{
Int maxIndex=0;//初始化为数组中一个元素的角标
For(int x=1;x<arr.length;x++)
{
If(arr[x]>arr[maxIndex])
maxIndex=x;
}
Return arr[maxIndex];
}


//获取最小值
Public static int getMin(int arr)
{
/.定变量记录较小的值；
Int min=arr[0];//初始化数组中的任意个元素；
//对数组进行遍历比较
For(int x=1;x<arr.length;x++)
{
If(arr[x]<min)
min=arr[x];
}
Return min;
}
//同样有另外一种方式获取最大值
Public static int getMin(int[] arr)
{
Int minIndex=0;//初始化为数组中一个元素的角标
For(int x=1;x<arr.length;x++)
{
If(arr[x]<arr[maxIndex])
    minIndex=x;
}
return arr[minIndex];
}

2.选择排序

思想：将数组中小的元素往索引小的一端排、大的元素往索引大的端排

(1).用0角标元素与1角标元素进行比较，如果0角标元素较大，通过第三方变量置换yu;如果0角标元素小于或等于1角标元素，不置换。
(2).再用0角标元素与2角标元素进行比较，如果0角标元素较大，0、2角标元素置换，
(3).以此类推，直至0角标元素与最后一个(arr.length-1)角标元素比较完 (4).再用1角标元素仿0角标的方式一次往后作比较。

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])
            {
            Int temp=arr[x];
            Arr[x]=arr[y];
            Arr[y]=temp;
            }
        }
    }
}   

/*从上面的排序中我们可以看出，对数组中元素进行置换位置的次数过多，也就是对堆内存的操作频繁，降低了性能，通过记录较小角标的方式减少堆内存的操作，性能优化。*/
//优化代码

Public static void selectSort_2（int[] arr）
    {
        For(int x=0;x<arr.length-1;x++)
            {
                Int num=arr[x];
                Int index=x;
                For(int y=x+1;y<arr.length;y++)
                    {
                        If(num>arr[y])
                            Num=arr[y];
                            Index=y;
                    }
                If(index!=x)
                {
                    int temp = arr[x];
                    arr[x] = arr[index];
                    arr[index] = temp;
                }

            }
}

3. 冒泡排序

思想：将数组中小的元素往索引大的一端排、小的元素往索引小的端排

(1).用0角标元素与1角标元素进行比较，如果0角标元素较大，通过第三方变量置换yu;如果0角标元素小于或等于1角标元素，不置换。
(2).再用1角标元素与2角标元素进行比较，如果1角标元素较大，1、2角标元素置换，
(3).以此类推，（0比1,1比2,2比3,3比4,4比5……..若前一个大于后一个置换）直至arr.length-2角标元素与arr.length-1角标元素比较完
(4).再用0比1,1比2,2比3,3比4……直至arr.length-3与arr.length-2进行比较
(5).最终使得0角标元素最小。

Public static void bubbleSort(int[] arr)
    {
        For(int x=0;x<arr.length-1;x++)
            {
                For(int y=0;y<arr.length-1-x;y++)//-1的目的是因为遍历到最后避免角标越界，-x是因为随着x的递增，参与比较的元素递减，   
                    {
                        If(arr[y]>arr[y+1])
                            {
                            //位置置换
                            int temp=arr[y];
                            arr[y]=arr[y+1];
                            arr[y+1]=temp;
                            }
                    }
            }
    }

4.折半查找—-首先要明确数组时有序的

思想：类似于高中数学中的二分法

(1).首先定义三个变量min、mid、max分来用来记录最小角标、中间角标、最大角标，中间角标的获取为(min+max)/2;
(2).用我们所需要查找的key与中间角标运算进行比较，如果key>arr[mid]，min=mid+1；如果key

Public static void binarySearch(int[] arr int key)
{
    Int min,mid,max;
    Min=0;
    Max=arr.length-1;
    Mid=(min+max)>>1//相当于/2，右移的效率比它要高
    While(arr[mid]!=key)
        {
        If(key>arr[mid])
            Min=mid+1;
        Else if（key<arr[mid]）
            Min=mid-1;
        If(max<min)
            Return -1;
        Mid=(max+min)>>1;
        }
    Return mid;
}

5.查表思想

思想：当同一类型的元素较多时，就使用数组这个容器对数据进行存储

//十进制--二进制
public static void toBin(int num)
{
    trans(num,1,1);
    }
//十进制--八进制
public static void toOctal(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)
        {
            Sop(0);
            Return;
        }
/*定义一个十六进制的元素表*/
    Char[] arr={'0', '1', '2',  '3', '4',  '5',  '6',  ' 7',  '8',  '9',  'A','  B',  'C' ,' D',  'E' ,'F'};
    Char[] chs=new char[32];
    Int pos=chs.length;
        While(num!=0)
        {
            Int temp=num&base;
            Chs[--pos]=arr[temp];
            num=num>>>offset;
        }
    For(ingt x=pos;x<chs.length;x++)
        {
            System.outr.println(chs[x]);
        }
}

---