Java数组——反转、扩容、缩容、查找、排序

目录

1.数组的反转

2.数组的扩容

3.数组的缩容

4.数组的查找

        1.顺序查找

        2.二分查找

5.数组的排序

        1.冒泡排序

        2.快速排序

---

1.数组的反转

class ReversalTest 
{
	public static void main(String[] args) 
	{
		int[] arr = {1,2,3,4,5};

		for (int i = 0;i < arr.length ;i++ ){
			System.out.print(arr[i]); //反转前
		}
		
		//反转
		//方法1：
		/*for (int i = 0;i < arr.length/2 ;i++ ){
			int temp = arr[i];
			arr[i] = arr[arr.length-1-i];
			arr[arr.length-1-i] = temp;
		}*/

		//方法2：
		for (int left = 0,right = arr.length-1;left<right ;left++,right-- ){
			int temp = arr[left];
			arr[left] = arr[right];
			arr[right] = temp;
		}
		
		System.out.println();

		for (int i = 0;i < arr.length ;i++ ){
			System.out.print(arr[i]); //反转后
		}

	}
}

2.数组的扩容

/*
	
	题目：现有数组 int[] arr = new int[]{1,2,3,4,5}; ，现将数组长度扩容1倍，
	并将10,20,30三个数据添加到arr数组中，如何操作？

*/
class ExpansionTest 
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{1,2,3,4,5};
		int[] arrNew = new int[arr.length<<1]; //长度扩容1倍

		for (int i = 0;i < arr.length ;i++ ){
			arrNew[i] = arr[i];
		}

		arrNew[arr.length] = 10;
		arrNew[arr.length + 1] = 20;
		arrNew[arr.length + 2] = 30;

		arr = arrNew;
		//遍历
		for (int i = 0;i < arr.length ;i++ ){
			System.out.print(arr[i] + "\t");
		}
	}
}

3.数组的缩容

class ShrinkageTest 
{
	public static void main(String[] args) 
	{
		int[] arr = {1, 2, 3, 4, 5, 6, 7};
        //删除数组中索引为4的元素
        int delIndex = 4;
        //方案1：
        /*//创建新数组
        int[] newArr = new int[arr.length - 1];
        for (int i = 0; i < delIndex; i++) {
            newArr[i] = arr[i];
        }
        for (int i = delIndex + 1; i < arr.length; i++) {
            newArr[i - 1] = arr[i];
        }
        arr = newArr;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/
        //方案2：
        for (int i = delIndex; i < arr.length - 1; i++) {
            arr[i] = arr[i + 1]; //后一个元素赋给前一个
        }
        arr[arr.length - 1] = 0;
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
	}
}

4.数组的查找

        1.顺序查找

class SearchTest 
{
	public static void main(String[] args) 
	{
		//顺序查找
		//查找value第一次在数组中出现的index
		int[] arr = {2,3,4,1,5};
        int value = 1;
        int index = -1;
        for(int i=0; i<arr.length; i++){
            if(arr[i] == value){
                index = i;
                break;
            }
        }

        if(index==-1){
            System.out.println(value + "不存在");
        }else{
            System.out.println(value + "的下标是" + index);
        }
	}
}

        2.二分查找

               1. 要求此数组必须是有序

class SearchTest 
{
	public static void main(String[] args) 
	{
		//二分查找
		int[] arr1 = new int[]{12,23,34,45,56,64,73,82,91};

		boolean isFlag = true;
		int value = 23;

		int head = 0;//首索引位置
		int end = arr1.length - 1;//尾索引位置

		while(head <= end){
			int middle = (head + end) / 2;
			if(arr1[middle] == value){
				System.out.println("找到指定的元素，索引为：" + middle);
				isFlag = false;
				break;
			}else if(arr1[middle] > value){
				end = middle - 1;
			}else{//arr1[middle] < value
				head = middle + 1;
			}
		}
		if(isFlag){
			System.out.println("未找打指定的元素");
		}
	}
}

5.数组的排序

        1.冒泡排序

class BubbleSort{
    public static void main(String[] args){
        int[] arr = {6,9,2,9,1};

        //目标：从小到大
        //冒泡排序的轮数 = 元素的总个数 - 1
        //轮数是多轮，每一轮比较的次数是多次，需要用到双重循环，即循环嵌套
        //外循环控制 轮数，内循环控制每一轮的比较次数和过程
        for(int i=1; i<arr.length; i++){ //循环次数是arr.length-1次/轮
			
            for(int j=0; j<arr.length-i; j++){
                //希望的是arr[j] < arr[j+1]
                if(arr[j] > arr[j+1]){
                    //交换arr[j]与arr[j+1]
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        //完成排序，遍历结果
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "  ");
        }

    }
}

        2.快速排序

                排序思想：

1. 从数列中挑出一个元素，称为"基准"（pivot），
2. 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
3. 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
4. 递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去