1.在数组中插入一个值 ：
在一个有序的数组中，插入一个数，保证数组依然有序
public class InsertDemo{
public static void main(String [] args ){
// 源数组
int [] oldArr ={23,34,56,58,87};
// 新数组
int [] newArr = new int [ oldArr.length+1 ];
// 【 2 】将源数组中的元素依次赋到新数组中
for ( int i =0; i < oldArr . length ; i ++){
newArr [ i ]= oldArr [ i ];
}
int number =100;
int index = newArr . length -1; // 用于记录合适索引
// 【 3 】找合适的位置
for ( int i =0; i < oldArr . length ; i ++){
if ( oldArr [ i ]> number ){
index = i ;
break ;
}
}
// 【 4 】移动位置
for ( int i = newArr . length -1; i > index ; i --){
newArr [ i ]= newArr [ i -1];
}
// 【 5 】将新元素插入到数组中
newArr [ index ]= number ;
TestArray.print( newArr );
}
}2.冒泡排序
N个数字来排队，两两相比，小靠前，外层循环N-1，内层循环N-1-i
import java.util.Arrays;
public class TestSort{
public static void main(String [] args){
int [] arr={43,55,35,4};
Arrays.sort(arr); //只能进行升序排序(自然排序)
TestArray.print(arr);
}
} public class Sort{
public static void bubbleSort(int [] array){
for(int i=0;i< array.length-1 ;i++){ //控制比较的轮数
for(int j=0;j< array.length-1-i ;j++){ //每轮比较的次数
if( array[j]>array[j+1] ){
//交换
int temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}
return;// array;
}
}3.选择排序法
//选择排序
//原理:每次都找到当次最大的数，按大小顺序依次放入数组相应位置
//比如:第一次先找到最大的数并记下其位置，如果其不在数组第一位，
//则将其与第一位交换，使最大数置于第一位
//第二次再循环查找第二大的数并记下其位置，如果其不在数组第二位，
//则将其与第二位交换，使最大数置于第二位
//依次类推.........................................
//第i次再循环查找第i大的数并记下其位置，如果其不在数组第 i位，
//则将其与第 i位交换，使最大数置于第 i位
public static void chooseSort(int[] array ){
for(int i=0;i< array.length-1 ;i++){ //轮数数
for(int j=i+1;j< array.length ;j++){ //每轮比较的次数
if( array[i]>array[j] ){
int temp=array[i];
array[i]=array[j];
array[j]=temp;
}
}
}
return;
}4.快速排序法：
//说明——快速排序法：对系统随机生成的0~100内的十个整数，按从小到大的顺序打印
public class S1008{
public static void main(String[] args){
int array[] = new int[10];
//用随机0~100的整数填充这个数组
for(int i = 0; i < array.length; i++){
array[i] = (int)(Math.random() * 100);
}
System.out.print("快速排序前的数组：");
show(array);
System.out.print("第一次快速排序的数组：");
quickSort(array, 0, array.length-1);
show(array);
System.out.print("快速排序完之后的数组：");
recursive(array, 0, array.length-1);
show(array);
}
// 打印数组
public static void show(int array[]){
for(int i = 0; i < 10; i++){
System.out.print(array[i] + " ");
}
System.out.println();
}
// 快速排序
public static int quickSort(int array[], int left, int right){
int value = array[left]; // 选取数组最左边的值作为中枢值
// 当左右指针未相遇时，循环排序
while(left < right){
// 将数组最右边的值取出与中枢值作比较，若比中枢值大，则指针左移，继续比较，
// 直到找到比中枢值小的值，然后交换位置
while(left < right && array[right] >= value){
--right;
}
array[left] = array[right];
// 找到之后，从右向左比较，找比中枢值大的数，找到之后就交换位置，找不到就指针右移
while(left < right && array[left] < value){
++left;
}
array[right] = array[left];
}
// 一遍排序完成，将中枢值放回，并将此时中枢值所在的位置返回
array[left] = value;
return left;
}
// 递归调用
public static void recursive(int array[], int left, int right){
if(left < right){
// 将中枢值所在位置存储于p变量中
int p = quickSort(array, left, right);
// 分别对中枢值左右两边进行递归调用
recursive(array, left, p-1);
recursive(array, p+1, right);
}
}
}5.二分查找
1.二分查找又称折半查找，它是一种效率较高的查找方法。
2.二分查找要求：（1）必须采用顺序存储结构 （2）.必须按关键字大小有序排列
3.原理：将数组分为三部分，依次是中值（所谓的中值就是数组中间位置的那个值）前，中值，中值后；将要查找的值和数组的中值进行比较，若小于中值则在中值前 面找，若大于中值则在中值后面找，等于中值时直接返回。然后依次是一个递归过程，将前半部分或者后半部分继续分解为三部分。
4.实现：二分查找的实现用递归和循环两种方式
package other;
public class BinarySearch {
/*
* 循环实现二分查找算法arr 已排好序的数组x 需要查找的数-1 无法查到数据
*/
public static int binarySearch(int[] arr, int x) {
int low = 0;
int high = arr.length-1;
while(low <= high) {
int middle = (low + high)/2;
if(x == arr[middle]) {
return middle;
}else if(x <arr[middle]) {
high = middle - 1;
}else {
low = middle + 1;
}
}
return -1;
}
//递归实现二分查找
public static int binarySearch(int[] dataset,int data,int beginIndex,int endIndex){
int midIndex = (beginIndex+endIndex)/2;
if(data <dataset[beginIndex]||data>dataset[endIndex]||beginIndex>endIndex){
return -1;
}
if(data <dataset[midIndex]){
return binarySearch(dataset,data,beginIndex,midIndex-1);
}else if(data>dataset[midIndex]){
return binarySearch(dataset,data,midIndex+1,endIndex);
}else {
return midIndex;
}
}
public static void main(String[] args) {
int[] arr = { 6, 12, 33, 87, 90, 97, 108, 561 };
System.out.println("循环查找：" + (binarySearch(arr, 87) + 1));
System.out.println("递归查找"+binarySearch(arr,3,87,arr.length-1));
}
}