Java代码算法（冒泡排序、选择排序、插入排序、快速排序、折半查找、数组反转）

1.冒泡排序

class A {
	public static void sort(int[] a) {
        //若数组长度为n，则一共排序n-1
		for (int i = 0; i < a.length - 1; i++) {
            //每次排出一个最大值(最小值)，每次少排一次
			for (int j = 0; j < a.length - 1 - i; j++) {
				if(a[j] > a[j + 1])
					swap(a, j, j + 1);//进行交换
			}
		}
	}
	//将传入的值进行交换
	static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
}

public class test {
	public static void main(String[] args) {
		int[] a = { 3, 2, 5, 4, 1, 7, 6 };
		A.sort(a);
		System.out.println(Arrays.toString(a));
	}
}

2.选择排序

class A {
	public static void sort(int[] a) {
		for (int i = 0; i < a.length - 1; i++) {
			int min = i;//最小值的下标从i开始
			//每次排序完成一次后，最小值会保存到i，j随着i的变化自增1(i从2开始，那么j就会是2+1)
			for (int j = i + 1; j < a.length; j++) {
				if(a[min] > a[j]) //如果a[0] > a[1] 则把j的下标赋给min
					min = j;
			}
			if(min != i) //如果min的下标不是i(相等代表这一轮循环中，最小的就是i本身，没有进行交换)
				swap(a, min, i);//进行交换
		}
	}

	static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}
}

public class test {
	public static void main(String[] args) {
		int[] a = { 3, 2, 5, 4, 1, 7, 6 };
		A.sort(a);
		System.out.println(Arrays.toString(a));
	}
}

3.插入排序

class A {
	public static void sort(int[] a) {
        //从1开始插入
		for (int i = 1; i < a.length; i++) {
			int value = a[i];
			int j = i - 1;
            //下标0位为有序，从1开始为无序
            //从1开始的值每次和前一位进行比较，如果比前一位的小，前一位的值覆盖后一位的值，不成立时，跳出while循环
            //因为最后一次还j--，将初始值value赋给j+1的位置
			while(j >=0 && a[j] > value) {
				a[j + 1] = a[j];
				j--;
			}
			a[j + 1] = value;	
		}
	}

//	public static void sort(int[] a) {
//		for (int i = 1; i < a.length; i++) {
//			int value = a[i];
//			int j = 0;
//			for (j = i - 1; j >= 0 && a[j] > value; j--) {
//				a[j + 1] = a[j];
//			}
//				a[j + 1] = value;
//		}
//	}
}

public class test {
	public static void main(String[] args) {
		int[] a = { 3, 2, 5, 4, 1, 7, 6 };
		A.sort(a);
		System.out.println(Arrays.toString(a));
	}
}

4.快速排序

class A {
	public static void sort(int[] a, int start, int end) {
        //如果数组为空，头尾下标相等或末尾的下标大于开始的下标则不再进行
		if (start > end || a == null) return;
		int i = start;
		int j = end;        
		int p = a[start];//定一个基准数a[0]
		
		while (i < j) {
            //(必须先从尾部判断)
            //先判断j,如果a[j]比基准数大，则j--
			while (i < j && p <= a[j]) j--;
            //判断i,如果a[i]比基准数小，则i++
			while (i < j && p >= a[i]) i++;
           	//如果循环内第一个while跳出(遇到比p小的)，循环内第二个while跳出循环(遇到比p大的)，就把遇到的数字进行调换
			if (i < j) {
				int temp = a[i];
				a[i] = a[j];
				a[j] = temp;
			}            
		}
        //跳出最外面的while循环，代表i和j相遇
            //将[i][j]相遇位置的坐标和p(a[start])进行调换(p就会在中间)，则p左边都是比p小的，右边都是比p大的
			a[start] = a[i];
			a[i] = p;
        //只是进行第一次分离，然后先判断左边的(因为i是中间的那个数了，所以没必要再进行判断，所以再判断左边的从start - [i - 1])，递归一直判断
		sort(a, start, i - 1);
		sort(a, i + 1, end);
}
}

public class test {
	public static void main(String[] args) {
		int[] a = { 3, 2, 5, 4, 1, 7, 6 };
		A.sort(a, 0, a.length - 1);
		System.out.println(Arrays.toString(a));
	}
}

5.折半查找

public class Test {
	public static int sort(int[] a, int find) {
		int start = 0;//开始位置
		int end = a.length - 1;//结束位置
		
		while (start <= end) {
			int mid = (start + end) / 2;//中间位置
            //找到直接退出，并返回下标
            if (find == a[mid]) return mid;
         //if找的值比中间的值小，则只需要找从start到中间的值(end = mid - 1)
			if (find < a[mid]) end = mid - 1;
         //if找的值比中间的值小，则只需要找从start到中间的值(end = mid + 1)
			if (find > a[mid]) start = mid + 1;			
		}
		return -1;//未找到返回-1
	}
	public static void main(String[] args) {
			//定义一个数组
			int[] a = {2, 3, 5, 1, 4, 8, 6, 7};
       		//折半查找之前，必须要先对数组进行排序
			Arrays.sort(a);
			System.out.println(Arrays.toString(a));
			int find = reverse.sort(a, 1);
			//找到的位置从0开始
			System.out.println(find);
	}
}

6.数组反转

public class reverse {
	public static void main(String[] args) {
        //第一种方法
		//定义一个数组
		int[] a = {2, 3, 5, 1, 4, 8, 6, 7};
		//从数组的开始到数组的中间，
		for (int i = 0; i < a.length / 2; i++) {
			int temp = a[i];
			a[i] = a[a.length - 1 - i];
			a[a.length - 1 - i] = temp;
		}
		System.out.println(Arrays.toString(a));
	}
}

	//第二种方法
public class reverse {
	public static void main(String[] args) {
		//定义一个数组
		int[] a = {2, 3, 5, 1, 4, 8, 6, 7};
		//当i < j的时候(只要下标一直小于就继续)
		for (int i = 0,j = a.length - 1; i < j; i++, j--) {
			int temp = a[i];
			a[i] = a[j];
			a[j] = temp;
		}
		System.out.println(Arrays.toString(a));
	}
}