冒泡:
static int[] bubbleSort(int[] data) {
System.out.println(Arrays.toString(data));
for (int i = data.length - 1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
if (data[j] > data[j + 1]) {
int temp = data[j];
data[j] = data[j + 1];
data[j + 1] = temp;
}
}
System.out.println(Arrays.toString(data));
}
return data;
}
选择:
static int[] selectionSort(int[] data) {
System.out.println(Arrays.toString(data));
for (int i = 0; i < data.length; i++) {
int min = data[i];
int index = i;
for (int j = i + 1; j < data.length; j++) {
if (data[j] < min) {
min = data[j];
index = j;
}
}
if (index != i) {
int temp = data[i];
data[i] = data[index];
data[index] = temp;
}
System.out.println(Arrays.toString(data));
}
return data;
}
插入:
static int[] insertSort(int[] arr, int len) {
System.out.println(Arrays.toString(arr));
int i;
int j;
int temp;
for (i = 1; i < len; i++) {
for (j = 0; j < i; j++) {
if (arr[j] > arr[i]) {
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
return arr;
}
归并(递归):
static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = left + (right - left) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
static void merge(int[] arr, int left, int mid, int right) {
int low = left;
int high = mid + 1;
int[] temp = new int[right - left + 1];
int tempIndex = 0;
while (low <= mid && high <= right) {
if (arr[low] < arr[high]) {
temp[tempIndex++] = arr[low++];
} else {
temp[tempIndex++] = arr[high++];
}
}
while (low <= mid) {
temp[tempIndex++] = arr[low++];
}
while (high <= right) {
temp[tempIndex++] = arr[high++];
}
System.arraycopy(temp, 0, arr, left, temp.length);
}
归并非递归:
static void mergeSort1(int[] data) {
if (data == null)
return;
int space = 2;
while (space < data.length) {
merge(data, space);
space = space << 1;
}
// 还需要一次归并
merge(data, space);
System.out.println(Arrays.toString(data));
}
static void merge(int[] data, int space) {
// 这一步是,传入的space是需要对里面进行归并的大小
// 除于2,temp值就是已经排好序的数组块的长度
int temp = space >> 1;
// 会改变的index
int leftStart = 0;
int rightStart = temp;
// 数组块归并时候的边界
int left = 0;
int right = space;
do {
int[] tempData = new int[space];
int tempIndex = 0;
// 条件的变动,可能最后一块归并的长度不够space,但是rightStart还是存在且小于数组的边界
while (leftStart < (left + temp) && rightStart < right && rightStart < data.length) {
if (data[leftStart] < data[rightStart]) {
tempData[tempIndex++] = data[leftStart++];
} else {
tempData[tempIndex++] = data[rightStart++];
}
}
while (leftStart < (left + temp)) {
tempData[tempIndex++] = data[leftStart++];
}
while (rightStart < right && rightStart < data.length) {
tempData[tempIndex++] = data[rightStart++];
}
// leftStart是关键,需要改变,copy时候的长度,到这一步rightStart已经遍历完规定的数组块
System.arraycopy(tempData, 0, data, left, rightStart - left);
// 重新分配归并的边界,和 2个指针的位置
leftStart = right;
rightStart = leftStart + temp;
left = leftStart;
right = leftStart + space;
} while (rightStart < data.length);
}
快排(递归):
static void quickSort(int[] data, int start, int end) {
if (start >= end) return;
int temp = data[start];
int left = start + 1;
int right = end;
while (left < right) {
while (data[right] > temp && left < right) {
right--;
}
while (data[left] < temp && left < right) {
left++;
}
if (left < right) {
int temp1 = data[left];
data[left] = data[right];
data[right] = temp1;
}
}
if (left != (start + 1) || data[left]<data[start]) {
data[start] = data[left];
data[left] = temp;
}
quickSort(data, start, left - 1);
quickSort(data, left + 1, end);
}
快排(非递归):
static void quickSort3(int[] data, int start, int end) {
if (start > end || data == null)
return;
Stack<Integer> stack = new Stack<>();
stack.push(start);
stack.push(end);
while (!stack.isEmpty()) {
Integer right = stack.pop();
Integer left = stack.pop();
if (left<right) {
int partition = partition(data, left, right);
stack.push(left);
stack.push(partition-1);
stack.push(partition+1);
stack.push(right);
}
}
}
static int partition(int[] data, int start, int end) {
int temp = data[start];
int left = start + 1;
int right = end;
while (left < right) {
while (data[right] > temp && left < right) {
right--;
}
while (data[left] < temp && left < right) {
left++;
}
if (left < right) {
int temp1 = data[left];
data[left] = data[right];
data[right] = temp1;
}
}
if (left != (start + 1) || data[left] < temp) {
data[start] = data[left];
data[left] = temp;
}
return left;
}