排序算法)
- 冒泡排序算法
public class Solution {
public int[] bubble(int[] nums){
// 外层循环
for (int i=0; i<nums.length; i++){
// 内层循环--比较相邻的数大小
for (int j=1; j<nums.length; j++){
// 判断大小
if(nums[j-1] > nums[j]){
// 前面大于后面--互换
int temp = nums[j-1];
nums[j-1] = nums[j];
nums[j] = temp;
}
}
}
return nums;
}
public static void main(String[] args){
int[] nums = {3,4,1,2,4,6,8,1};
Solution solution = new Solution();
int[] bubble = solution.bubble(nums);
for (int bu : bubble) System.out.print(bu+" ");
}
}
2. 插入排序算法
public class Solution {
public int[] insert(int[] nums){
// j是记忆要插入的位置,外循环结束时插入进去
// 定义临时变量temp 保存每次要插入的数
int j, temp = 0;
// 外循环, i=1 开始,第0位是默认排序好的
for (int i=1; i<nums.length; i++){
// 要插入的数
temp = nums[i];
// 内循环
// 第i位数字 与 i前面 的数字比较,
// 1.如果 nums[i] > nums[j] 即i前面的数,
// 后面的 j 往后移一位 , 前面的位置空出来插入nums[i],
// 在 j-1 在继续往前比较, 直到找到一个不大于nums[i]的数,
// 或者移到 第 0 位 结束内循环,
// 跳出内循环 把 j+1 位就是要插入的位置,
// 为什么是j+1 位呢? 每次比较完 j都进行了一次 j--,
// 所有 j是比实际位置小一位, 所以要加一,
// 2.如果从一开始 nums[i] 大于前面的,就直接跳出循环,
// 因为前面的是排序好的,一定比后面的小,
// 不像冒泡排序法, 每次内循环结束前面可能出现没有排序好的。
for (j = i-1; j>=0; --j){
// 要插入的数 与 前面的数 比较
if(nums[j] > temp){
// 前面一个往后移一位
nums[j+1] = nums[j];
}else{
break;
}
}
// 记录的临时变量插入 要插入的位置 j+1
nums[j+1] = temp;
}
return nums;
}
public static void main(String[] args){
int[] nums = {3,4,1,2,4,6,8,1};
Solution solution = new Solution();
int[] insert = solution.insert(nums);
for (int inset : insert) System.out.print(inset+" ");
}
}
**3. 链表插入排序算法 **
public class Solution {
public ListNode insertionSortList(int[] nums) {
// 数组为空 返回空数组
if (nums.length == 0) return null;
// 创建一个链表 , 把数组第一个元素作为头节点
ListNode head = new ListNode(nums[0]);
// 创建一个节点 指向头节点 current = head
// -1 -> null
ListNode current = head;
for (int i = 1; i < nums.length; i++) {
// ListNode(nums[i]) 创建一个节点
// 并赋给 current下一个节点 current.next
current.next = new ListNode(nums[i]);
// -1 -> 5 -> null
// current = current.next 指向下一个节点
// 指针往下移
current = current.next;
}
// 创建一个 哑节点 当作头节点
ListNode dummyHead = new ListNode(0);
// dummyHead.val = 0
// dummyHead.next -> head 就等于
// 0 -> -1 -> 5 -> 3 -> 4 -> 0 -> null
dummyHead.next = head;
// 创建一个排序的 要排序比较节点 lastSorted
// lastSorted 前面的节点都是排序好的
// 和当前的节点 curr
// 注意的是 curr = head.next 比 lastSorted = head 后一位
// curr: 5 -> 3 -> 4 -> 0 -> null
// lastSorted:-1 -> 5 -> 3 -> 4 -> 0 -> null
ListNode lastSorted = head, curr = head.next;
// 如果 curr 还有节点就继续循环
while (curr != null) {
// lastSorted 当前节点 <= curr当前节点
// lastSorted 和 curr 都要移一位
// -1 < 5
if (lastSorted.val <= curr.val) {
// lastSorted 往下移
lastSorted = lastSorted.next;
}
// 5 > 3
else {
// 创建一个y临时节点,当作 前节点
ListNode prev = dummyHead;
// 因为 lastSorted.val <= curr.val
// 所以 要找到 lastSorted前一个节点
// prev.next.val <= curr.val 来找到前一个节点
while (prev.next.val <= curr.val) {
// 没有找到继续往下走
prev = prev.next;
}
// 跳出循环说明找到了
// prev = -1 lastSorted = 5 curr = 3
// lastSorted.next = curr.next;
// lastSorted.next -> 4 -> 0 -> null
// curr 的前节点断开了
lastSorted.next = curr.next;
// curr.next = prev.next;
// curr.next 指向prev.next节点
// prev.next 原来是指向 lastSorted
// lastSorted.val = 5
// 所以现在 curr.next -> 5 -> 4 -> 0 -> null
// curr.val的位置没有变 还是等于 3
curr.next = prev.next;
// prev.next = curr;
// curr.val = 3
// prev.next -> 3 -> 5 -> 4 -> 0 -> null
prev.next = curr;
// 最后 prev = -1 lastSorted = 5 curr = 3
// 节点指向的next 改变了
}
// -1 -> 3 -> 5 -> 4 -> 0 -> null
// curr 往下移一位
curr = lastSorted.next;
}
return dummyHead.next;
}
public static void main(String[] args){
int[] x = {-1,5,3,4,0};
Solution solution= new Solution();
ListNode listNode = solution.insertionSortList(x);
while (listNode != null){
System.out.printf("%d -> ",listNode.val);
listNode = listNode.next;
}
}
}
** 4. 选择排序算法**
public class Solution {
public int[] select(int[] nums){
// 外循环
for (int i=0; i<nums.length; i++){
// 记录要排序的位置, 从0开始一位一位 排序
int minInt = i;
// 内循环
// 第 i 位要排序的位置 不用比较
// i 前面的都是排序好的
for(int j=i+1; j<nums.length; j++){
// nums[j] < nums[minInt]
// 找到 最小数的 的位置(下标)
if(nums[j] < nums[minInt]){
minInt = j;
}
}
// 如果 i != minInt 说明最小的位置不是在 i 位继续交换
// 如果 第 i 位是最小的 j 就没有赋给过 minInt, i = minInt
// 所以加上判断 减少比较
if(i != minInt){
// 要排序的位置的值 与 最小的的位置的值 进行 交换
int temp = nums[i];
nums[i] = nums[minInt];
nums[minInt] = temp;
}
}
return nums;
}
public static void main(String[] args) {
int[] nums = {3, 4, 1, 2, 4, 6, 8, 1};
Solution solution = new Solution();
int[] select = solution.select(nums);
for (int se : select) System.out.print(se + " ");
}
}
这是我自己理解的排序算法,
看不懂得可以问我,我也是一个菜鸡,
刚学算法不久。
关注我公众号: 老许学Java
大家一起学习呀。