剑指offer_剑指offer 下载-CSDN博客

本文链接：https://blog.csdn.net/AinUser/article/details/81274581

面试题5 ：从尾到头打印链表(翻转链表)

public class Test05 {
/**
* 结点对象
*/
public static class ListNode {
int val; // 结点的值
ListNode nxt; // 下一个结点
}
/**
* 输入个链表的头结点，从尾到头反过来打印出每个结点的值
* 使用栈的方式进行
*
* @param root 链表头结点
*/
public static void printListInverselyUsingIteration(ListNode root) {
Stack<ListNode> stack = new Stack<>();
while (root != null) {
stack.push(root);
root = root.nxt;
}
ListNode tmp;
while (!stack.isEmpty()) {
tmp = stack.pop(); //记忆移除stack的最后一个值
System.out.print(tmp.val + " ");
}
}
/**
* 输入个链表的头结点，从尾到头反过来打印出每个结点的值
* 使用栈的方式进行
*
* @param root 链表头结点
*/
public static void printListInverselyUsingRecursion(ListNode root) {
if (root != null) {
printListInverselyUsingRecursion(root.nxt);
System.out.print(root.val + " ");
}
}
public static void main(String[] args) {
ListNode root = new ListNode();
root.val = 1;
root.nxt = new ListNode();
root.nxt.val = 2;
root.nxt.nxt = new ListNode();
root.nxt.nxt.val = 3;
root.nxt.nxt.nxt = new ListNode();
root.nxt.nxt.nxt.val = 4;
root.nxt.nxt.nxt.nxt = new ListNode();
root.nxt.nxt.nxt.nxt.val = 5;
printListInverselyUsingIteration(root);
System.out.println();
printListInverselyUsingRecursion(root);
}
}

运行结果：

冒泡排序（java版）

/**
* author: Ain
* model: write a code about bubble_sort
* date:2016-2-18
*/
private static final int [] ARRAY_NUMBER =  {2,3,1,4,6,5};
//主main程序
public static void main(String[] args) {
    //借用无返回值方法进行排序
    bubble_Sort(ARRAY_NUMBER);
    //进行循环输出
    for(int i=0;i<ARRAY_NUMBER.length;i++){
        System.out.print(ARRAY_NUMBER[i]);
    }
}
/**
* model:write a method about bubble_sort
* author:Ain
* 冒泡排序：双层for循环+一层if判断
*/
public static void bubble_Sort(int[] ARRAY_NUMBER){
    //  首层循环控制：趟数
    for(int i = 0; i<ARRAY_NUMBER.length;i++){
        //二层循环控制：比较次数
        for(int j = 0;j<ARRAY_NUMBER.length-i-1;j++){
            //二层循环中if条件语句进行判断
            if(ARRAY_NUMBER[j]>ARRAY_NUMBER[j+1]){
                //进行位置交换
                int temp = ARRAY_NUMBER[j];
                ARRAY_NUMBER[j] = ARRAY_NUMBER[j+1];
                ARRAY_NUMBER[j+1] = temp;
            }
        }
    }
}

冒泡排序（python版）

def bubble_sort(nums):

for i in range(len(nums) - 1): # 这个循环负责设置冒泡排序进行的次数

for j in range(len(nums) - i - 1): # j为列表下标

if nums[j] > nums[j + 1]:

nums[j], nums[j + 1] = nums[j + 1], nums[j]

return nums

print(bubble_sort([45, 32, 8, 33, 12, 22, 19, 97]))

总结：

冒泡排序总的平均时间复杂度为

冒泡排序是一种稳定排序算法

选择排序(java版)

/**
* author: Ain
* model: write a code about bubble_sort
* date:2016-2-18
*/
private static final int[] ARRAY_NUMBER = {2, 3, 1, 4, 6, 5};

//主main程序
public static void main(String[] args) {
    //借用无返回值方法进行排序
    bubble_Sort(ARRAY_NUMBER);
    //进行循环输出
    for (int i = 0; i < ARRAY_NUMBER.length; i++) {
        System.out.print(ARRAY_NUMBER[i]);
    }
}

/**
* model:write a method about bubble_sort
* author:Ain
* 选择排序
*/
public static void bubble_Sort(int[] ARRAY_NUMBER) {
    //类选择排序算法
    for (int i = 0; i < ARRAY_NUMBER.length - 1; i++) {
        for (int j = (ARRAY_NUMBER.length - 2); j >= i; j--) {
            if (ARRAY_NUMBER[j] < ARRAY_NUMBER[j + 1]) {
                int temp = ARRAY_NUMBER[j];
                ARRAY_NUMBER[j] = ARRAY_NUMBER[j + 1];
                ARRAY_NUMBER[j + 1] = temp;
            }
        }
    }
    //选择排序
    int temp;
    for(int i=0;i<ARRAY_NUMBER.length;i++){
        //内层循环j=i+1,外层循环控制着循环次数。即每趟中a[i]这个值就是本趟的最小值。i位置上是最小值
        for(int j=i+1;j<ARRAY_NUMBER.length;j++){
            if(ARRAY_NUMBER[i]>ARRAY_NUMBER[j]){
                temp=ARRAY_NUMBER[i];
                ARRAY_NUMBER[i]=ARRAY_NUMBER[j];
                ARRAY_NUMBER[j]=temp;
            }
        }
    }
}