Java数据结构学习Day2_Java基础排序算法
1.冒泡排序
冒泡排序就是用双重循环，从数组的头部开始遍历，如果当前数比后一个数大，则调换两者的位置，时间复杂度为O(n^2),冒泡排序很好理解，就是相邻两个数字交换位置即可
package Ivan.sort;
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {3, 4, 5, 12, -1, -34};
int temp = 0;
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length; j++) {
if (arr[i] < arr[j]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
2.选择排序
第一次从arr[0] - arr[n-1]中选取最小值与arr[0]交换，第二次从arr[1]-arr[n-1]中再选最小值和arr[1]交换，以此类推，时间复杂度也是o(n^2)，选择排序也比较简单，多看两遍代码就能理解，每次选择剩余数组中最小的数和剩余数组中的第一个数交换位置
package Ivan.sort;
public class SelectSort {
public static void main(String[] args) {
int arr[] = {1, -1, 3, -4, -5, 5};
for (int i = 0; i < arr.length; i++) {
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {
min = arr[j];
minIndex = j;
}
}
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
3.插入排序
把n个待排序的元素看成一个有序表和一个无序表，无序表中有n-1个元素，有序表中只有一个元素，每次排序从无序表中取出一个元素插入到有序表中，最后返回有序表，最坏的时间复杂度也是o(n^2)
package Ivan.sort;
public class insertSort {
public static void main(String[] args) {
int arr[] = {1, -1, 3, -4, -5, 5};
for (int i = 1; i < arr.length; i++) {
int insertValue = arr[i];
int index = i - 1;
while (index >= 0 && insertValue < arr[index]) {
arr[index + 1] = arr[index];
index--;
}
arr[index + 1] = insertValue;
}
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
4.希尔排序
希尔排序也是一种插入排序，是由简单排序改进之后的一个更高效的版本，把数组进行一定增量的分组，对每组使用直接插入排序算法排序，希尔排序比较难理解的就是步长，可以理解成把第i个元素和i+步长的元素比较大小，交换位置或是移动位置
package Ivan.sort;
public class ShellSort {
public static void main(String[] args) {
int arr[] = {1, -1, 3, -4, -5, 5, 34, 67, -4, -4, 15, 6, -523};
Shell2(arr);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
//交换式
public static void Shell(int arr[]) {
int temp = 0;
for (int i = arr.length / 2; i > 0; i /= 2) {
for (int j = i; j < arr.length; j++) {
for (int k = j - i; k >= 0; k -= i) {
if (arr[k] > arr[k + i]) {
temp = arr[k];
arr[k] = arr[k + i];
arr[k + i] = temp;
}
}
}
}
}
//移动式
public static void Shell2(int arr[]) {
for (int i = arr.length / 2; i > 0; i /= 2) { //i为步长
for (int j = i; j < arr.length; j++) {
int k = j;
int temp = arr[j];
if (arr[j] < arr[j - i]) {
while (k - i >= 0 && temp < arr[k - i]) {
arr[k] = arr[k - i];
k -= i;
}
arr[k] = temp;
}
}
}
}
}
5.快速排序
快排是对冒泡排序的一种改进，基本思想是：经过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据要小，再按此方法对这两部分数据进行快排，递归的思路，快排比较难理解的就是找一个基准数，把左右两边的数都拍好以后，再对左右两边的分别进行快排，要理解递归的思路
package Ivan.sort;
public class quickSort {
public static void main(String[] args) {
int arr[] = {1, -1, 3, -4, -5, 5, 34, 67, -4, -4, 15, 6};
quickSort(arr, 0, arr.length - 1);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
public static void quickSort(int[] arr, int left, int right) {
int l = left;
int r = right;
int temp = 0;
int p = arr[(left+right)/2];
while (l<r){
//找到左边比p大的值
while (arr[l]<p){
l++;
}
//找到右边比p小的值
while (arr[r] > p){
r--;
}
if (l>=r) break;
//找到了就交换位置
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//交换完后发现arr[l] == p，前移
if (arr[l] == p){
r -= 1;
}
if (arr[r] == p){
l += 1;
}
}
//递归左边和右边
//如果l==r，必须l++,r--，否则栈溢出
if (l==r){
l++;
r--;
}
if (left<r) quickSort(arr, left, r);
if (right>l) quickSort(arr, l, right);
}
}
