java-数组-增删改查

问题一：找出最大值（最大或最小）

法一：用一个中间变量（默认是a[0]）与数组每一个值比较,大的就赋值给中间变量

法二：找出最大值的下标，用一个下标变量（默认‘0’）与数组的每个值比较，大的就赋该值的下标给变量

问题二：数组的查找操作。（二分法的应用：对于有序的序列）

练习：有一个有序的数组，想要将一个元素插入到该数组中，
                还要保证该数组是有序的。如何获取该元素在数组中的位置。
                即在[1,3,6,8,9],插入一个7，而且保持有序

 1 //利用二分法查找
 2     //二分法：重点以中间值开始比较，key大的话以中间值后一位为起点开始查找，相反类推
 3     //key小的以中间值前一位为起点开始找
 4     public static int halfSearch(int[]arr,int key)
 5     {
 6         //设置要查询范围的首和尾的下标
 7         int s=0,e=arr.length-1;
 8         //设一个中间值下标,默认-1
 9         int h;
10         //当首小于尾时才循环，没有循环次数要求。所以用while
11          while(s<=e)
12        {
13             //中间变量下标,
14               h=(s+e)/1;
15             if(arr[h]<key)
16             {
17                 s=h+1;//必须+1，以此为起点
18                 //System.out.println(h);
19             }
20             else if(arr[h]>key)
21             {
22                 e=h-1;//必须-1，以此为终点
23             }
24             else if(arr[h]==key)
25             {
26                 //第三种情况，两者相等，则跳出循环
27                 return h;
28             }
29             //System.out.println("dd");
30         }
31          //这里必须是s,不是h,因为while循环里一种情况是arr[h]==key,而另一种情况就是下面的
32         return s;
33      }

问题二：排序（从小到大）

Java排序方法：1.冒泡排序。2.选择排序。3.插入排序。4.快速排序。

1.冒泡排序法：

 1     //冒泡排序法：从a[0]开始，每个相邻的数比较，较大时，两者交换。
 2     //第一次将最大值交换到了最后一位，第二次交换到倒数第二位，以此类推
 3     //这里要从小到大排序
 4     public static void bubbleSort(int[]arr)
 5     {
 6         //首先一定是两次for循环
 7         for(int i=1;i<arr.length;i++)
 8         {
 9             for(int k=0;k<arr.length-i;k++)
10             {
11                 //交换要用到中间变量
12                 int tmp;
13                 if(arr[k]>arr[k+1])
14                 {
15                     tmp=arr[k+1];
16                     arr[k+1]=arr[k];
17                     arr[k]=tmp;
18                 }
19              }
20           }
21   }

2.选择排序

 1 //选择排序法：找出最大值，放在最后一位，再从剩下的数找最大值，以此类推
 2     //第一次循环，从0到n,用下标找出最小值，然后与最后一位（n）交换，
 3     //第二次循环，从0到n-1,找出最小值再与(n-1)位交换，以此类推
 4     //首先想到两次for循环！！！
 5     //这里是从大到小排列，
 6     public static void selectSort(int[]arr)
 7     {
 8          for(int i=1;i<arr.length;i++)
 9         {
10             //默认下标为0,每一次都从0开始与后面比较
11             int min=0;
12
13             for(int k=0;k<arr.length-i;k++)
14             {
15                 //找出最小值
16                 if(arr[k+1]<arr[min])
17                     min=k+1;
18              }
19             //循环完后找出了最小值的下标
20             //与最后一位交换!!（交换必须想到用中间变量！！）
21             //System.out.print(arr[min]+"\t");
22             //中间变量用于交换
23             int tmp;
24             tmp=arr[arr.length-i];
25             arr[arr.length-i]=arr[min];
26             arr[min]=tmp;
27         }
28      }

3.插入排序

 1 //插入排序法：以第一个数为始点，拿后面的第二个数比较，较大插入到它的后面，
 2     //否则前面，第三个数开始与前面的第二个比较，直到交换到比前面的数大
 3     //这里的插入实际就是交换值（位置）
 4     //这里从小到大排序
 5     public static void insertSort(int[]arr)
 6     {
 7         //进行n-1次的交换
 8         for(int i=1;i<arr.length;i++)
 9         {
10             //从第一个和第二个开始比较插入
11             //比较次数依次增加
12             int tmp;
13             for(int k=i;k>0;k--)
14             {
15                 //这里是从最后面的那个元素即i开始与前面比较的
16                 if(arr[i]<arr[k-1])
17                 {
18                     //实现交换
19                     tmp=arr[i];
20                     arr[i]=arr[k-1];
21                     arr[k-1]=tmp;
22                 //注意交换后，i即下标要改为交换后的位置的下标即k-1
23                     i=k-1;
24                 }
25                 //如果刚好最后一个大于倒数第二个，则不必循环了
26                 else break;
27              }
28          }
29    }

4.快速排序

//快速排序法（挖坑填数+分治法）：
    public static void quikSort(int []arr)
    {

    }