java简单算法题_java实现9道简单算法题

//【1】**********************************************************************************************

/**

* 将一个三位数反转

* @param number

* @return

*/

public int reverseNumber(int number) {

System.out.println("=== start: 将一个三位数反转");

//验证三位数

int wholeNumber = number / 100;

if (wholeNumber == 0 || wholeNumber > 9 ) {

System.out.println("不是三位数，请重新输入");

return -1;

}

//方法一：利用String,charArr,Integer相互转化的函数；2.两个位置临时交换

String digitalStr = String.valueOf(number);

char[] charArr = digitalStr.toCharArray();

char charOne = charArr[0];

charArr[0] = charArr[2];

charArr[2] = charOne;

int resultDigital = Integer.valueOf(String.valueOf(charArr));

System.out.println("result: " + resultDigital);

return resultDigital;

//TODO 方法二：继续完善,不用String包装类

}

//【2】**********************************************************************************************

/**

* 将一个小写自己转为大写字母

*/

public char lowercaseToUppercase(char character) {

System.out.println("=== start: 将一个小写自己转为大写字母");

System.out.println("input: " + character);

//判断小写字符

//方法一：

// 根据条件，转换成对应的大小写

String s = String.valueOf(character);

char resultChar = s.toUpperCase().toCharArray()[0];

//TODO:方法二：

//根据ascii值

System.out.println("result: " + resultChar);

return resultChar;

}

//【3】**********************************************************************************************

/**

* 发现斐波那契中第N个数

* @param n

* @return

*/

public int findNFibonaci(int n) {

System.out.println("=== start: 发现斐波那契中第N个数");

int first = 0;

int second = 1;

int third = -1;

if (n <= 0) {

} else if (n == 1) {//写错了，写成了if( i==1 )

third = first;

} else if (n == 2) {

third = second;

} else {

for (int i = 3; i <= n; i++) {

third = first + second;

first = second;

second = third;

System.out.println("第"+ i +"位: " + third);

}

}

System.out.println("result: " + third);

return third;

}

//【4】**********************************************************************************************

/**

* https://lintcode.com/problem/remove-linked-list-elements/description

* 删除链表中等于给定值val的所有节点。

*/

//Definition for ListNode

public class ListNode {

int val;

ListNode next;

ListNode(int x) {

val = x;

next = null;

}

@Override

public String toString() {

StringBuffer stringBuffer = new StringBuffer();

ListNode nowNode = this;

while (nowNode != null) {

stringBuffer.append(nowNode.val + "->");

nowNode = nowNode.next;

}

return stringBuffer.toString();

}

}

/**

* @param head: a ListNode

* @param val: An integer

* @return: a ListNode

*/

public ListNode removeElements(ListNode head, int val) {

if (head == null)

return null;

//方法1：前一个(n-1)节点的next指向n+1个节点

ListNode nowNode = head;

ListNode preNode = null;

ListNode validNode = null;

ListNode preValidNode = null;

while(nowNode != null) {

if (nowNode.val == val) {

// if (preNode == null) {

// } else {

// preNode.next = nowNode.next;

// }

if (preNode == null) {

preNode = nowNode;

} else {

preNode.next = nowNode.next;

}

} else {

// if (preValidNode == null) {

// preValidNode = nowNode;

// } else {

// preValidNode.next = nowNode;

// preValidNode = nowNode;

// }

// if (validNode == null) {

// validNode = nowNode;

// } else {

// validNode.next = nowNode;

// preNode = nowNode;

// }

preNode = nowNode;

}

nowNode = nowNode.next;

}

//处理第一个节点

if(head.val == val) {

head = head.next;

}

//方法2???:创建新的链表，只有记录新的节点

return head;

}

/**

* 实例：

* 1. 1-2-3-4 删除 2，3，4(简单)； 删除1(比较难)

* 1. 1-2-3-3-4-3 删除 3(简单)

*/

private void testRemoveElements() {

ListNode resultNode = new ListNode(1);

ListNode next2 = new ListNode(2);

resultNode.next = next2;

ListNode next3 = new ListNode(3);

next2.next = next3;

ListNode next4 = new ListNode(4);

next3.next = next4;

System.out.println("primary: " + resultNode.toString() + ";val:" + 1);

ListNode result = removeElements(resultNode, 1);

System.out.println("result: " + result.toString());

//case2:

ListNode resultNode2 = new ListNode(1);

ListNode next22 = new ListNode(2);

resultNode2.next = next22;

ListNode next23 = new ListNode(3);

next22.next = next23;

ListNode next24 = new ListNode(3);

next23.next = next24;

ListNode next25 = new ListNode(4);

next24.next = next25;

ListNode next26 = new ListNode(3);

next25.next = next26;

System.out.println("primary2: " + resultNode2.toString() + ";val:" + 3);

ListNode result2 = removeElements(resultNode2, 3);

System.out.println("result2: " + result2.toString());

//case 3

ListNode resultNode3 = new ListNode(1);

ListNode next32 = new ListNode(1);

resultNode3.next = next32;

ListNode next33 = new ListNode(1);

next32.next = next33;

ListNode next34 = new ListNode(4);

next33.next = next34;

System.out.println("primary3: " + resultNode3.toString() + ";val:" + 1);

ListNode result3 = removeElements(resultNode3, 1);

System.out.println("result3: " + result3.toString());

}

//【5】**********************************************************************************************

/**

* 实现一个矩阵类Rectangle，包含如下的一些成员变量与函数：

两个共有的成员变量 width 和 height 分别代表宽度和高度。

一个构造函数，接受2个参数 width 和 height 来设定矩阵的宽度和高度。

一个成员函数 getArea，返回这个矩阵的面积。

*/

public class Rectangle {

private int width;

private int height;

public Rectangle(int width, int height) {

this.width = width;

this.height = height;

}

public int getArea() {

int area = width * height;

return area;

}

}

public void testRectangle() {

Rectangle rec = new Rectangle(3, 4);

int area = rec.getArea(); // should get 12

System.out.println("primary: width-3,height:4;area?");

System.out.println("result: " + area);

}

//【6】******************************************************************************************

/**

* 给一组整数，按照升序排序，使用选择排序，冒泡排序，插入排序或者任何 O(n2) 的排序算法。

* 总结：排序和查找是两种操作。

* @param A: an integer array

* @return: nothing

*/

public void sortIntegers(int[] A) {

// 冒泡排序：---小的冒泡

if (A == null || A.length <= 1) {

return;

}

int size = A.length;

System.out.println();

System.out.print("[");

for(int i = 0; i < size; i++) {

System.out.print(" " + A[i]);

}

System.out.print("]");

int exchangeCount = 1;

int count = 0;

while (exchangeCount > 0){

exchangeCount = 0;

for(int j = 0; j < size -1; j++) {

if (A[j] > A[j+1]) {

int temp = A[j];

A[j] = A[j+1];

A[j+1] = temp;

exchangeCount++;

}

}

count++;

}

System.out.println("count:" + count);

System.out.print("[");

for(int i = 0; i < size; i++) {

System.out.print(" " + A[i]);

}

System.out.print("]");

// 选择排序

// 插入排序???

}

public void sortIntegersByChoose(int[] A) {

// 选择排序

if (A == null || A.length <= 1) {

return;

}

int size = A.length;

//log

System.out.println();

System.out.print("[");

for(int i = 0; i < size; i++) {

System.out.print(" " + A[i]);

}

System.out.print("]");

int curIndex;

int minIndex;

for(int i = 0; i < size - 1; i++) { //循环次数:5次

curIndex = i; //概念

minIndex = curIndex;

for(int j = curIndex + 1; j < size; j++) { //循环次数：4，3，2，1

if (A[minIndex] > A[j]) {

minIndex = j;

}

}

if (minIndex != curIndex) {

int temp = A[curIndex];

A[curIndex] = A[minIndex];

A[minIndex] = temp;

}

}

//log

System.out.println();

System.out.print("[");

for(int i = 0; i < size; i++) {

System.out.print(" " + A[i]);

}

System.out.print("]");

}

public void sortIntegersByInsert(int[] A) {

// 插入排序：---插入已经排好序的数组中

if (A == null || A.length < 1) {

return;

}

int size = A.length;

//log

System.out.println();

System.out.print("[");

for(int i = 0; i < size; i++) {

System.out.print(" " + A[i]);

}

System.out.println("]");

int changeCount = 0;

int reverseCount = 0;

for(int i = 1; i < size;i++) {

int tempIndex = i - 1;

for(int j = tempIndex; j >= 0; j--) {

reverseCount++;

if(A[j+1] < A[j]) {

int tempVal = A[j+1];

A[j+1] = A[j];

A[j] = tempVal;

changeCount++;

} else {

break;

}

}

}

System.out.println("changeCount: " + changeCount);

System.out.println("reverseCount: " + reverseCount);

System.out.print("[");

for(int i = 0; i < size; i++) {

System.out.print(" " + A[i]);

}

System.out.println("]");

}

private void testSort() {

//case 1

int[] intArr = new int[]{4,3,2,5,1};

sortIntegers(intArr);

//case 2

int[] intArr1 = new int[]{4,3,2,5,1, 8,2};

sortIntegers(intArr1);

//case 3

int[] intArr2 = new int[]{1,2,3,4,5,6};

sortIntegers(intArr2);

}

private void testSortByChoose() {

//case 1

int[] intArr = new int[]{4,3,2,5,1};

sortIntegersByChoose(intArr);

//case 2

int[] intArr1 = new int[]{4,3,2,5,1, 8,2};

sortIntegersByChoose(intArr1);

//case 3

int[] intArr2 = new int[]{1,2,3,4,5,6};

sortIntegersByChoose(intArr2);

}

private void testSortByInsert() {

//case 1

int[] intArr = new int[]{4,3,2,5,1};

sortIntegersByInsert(intArr);

//case 2

int[] intArr1 = new int[]{4,3,2,5,1, 8,2};

sortIntegersByInsert(intArr1);

//case 3

int[] intArr2 = new int[]{1,2,3,4,5,6};

sortIntegersByInsert(intArr2);

}

//【7】*****************************************************************************

/**

* 链表节点计数

* 描述

* 计算链表中有多少个节点

* @param head

* @return

*/

public int countNodes(ListNode head) {

// write your code here

int count = 0;

while (head != null) {

count++;

head = head.next;

}

System.out.println("countNodes:" + count);

return count;

}

private void testCountNodes() {

//case 1

ListNode resultNode = new ListNode(1);

ListNode next2 = new ListNode(2);

resultNode.next = next2;

ListNode next3 = new ListNode(3);

next2.next = next3;

ListNode next4 = new ListNode(4);

next3.next = next4;

countNodes(resultNode);

countNodes(next3);

countNodes(next4);

countNodes(next4.next);

}

//【8】**********************************************************************************************

/**

数组第二大数

在数组中找到第二大的数

方法：选择排序最简单

*/

public int secondMax(int[] nums) {

// write your code here

if(nums == null || nums.length == 0 || nums.length == 1) {

return -1;

}

int size = nums.length;

int reverseCount = 2;

if (size == 2 ) {

reverseCount = 1;

}

for(int i = 0; i < reverseCount; i++) {

int maxIndex = i;

for(int j = i + 1; j < size; j++) {

if (nums[maxIndex] < nums[j]){

maxIndex = j;

}

}

if (maxIndex != i) {

int tempVal = nums[maxIndex];

nums[maxIndex] = nums[i];

nums[i] = tempVal;

}

}

return nums[1];

}

public void testSecondMax() {

int[] intArr1 = new int[]{3,1,4,2,5};

int secondMax = secondMax(intArr1);

System.out.println("secondMax:" + secondMax);

}

//【9】**********************************************************************************************

/**

交换数组两个元素---【入门】

给你一个数组和两个索引，交换下标为这两个索引的数字

样例

给出 [1,2,3,4] index1 = 2, index2 = 3. 交换之后变成 [1,2,4,3]

*/

public void swapIntegers(int[] A, int index1, int index2) {

if (A == null || A.length == 0 || index1 == index2 || index1 < 0 || index2 < 0

|| index1 >= A.length || index2 >= A.length) {

return;

}

System.out.println("origin array:");

for(int i = 0; i < A.length; i++) {

System.out.print(A[i] + " ");

}

System.out.println();

System.out.println("swapIndex: " + index1 + " " + index2);

int tempVal = A[index1];

A[index1] = A[index2];

A[index2] = tempVal;

System.out.println("new array:");

for(int i = 0; i < A.length; i++) {

System.out.print(A[i] + " ");

}

}

public void testSwapInteger() {

int[] intArr1 = new int[]{3,1,4,2,5};

swapIntegers(intArr1, 1,2);

}