数据结构和算法

数据结构

栈

public class Stack {
private int[] array = new int[5];// 栈
private int top = -1;// 指针

// 压栈
public boolean push(int x) {
if(top<array.length-1){
array[++top] = x;
return true;
}else{
throw new RuntimeException("overFlow");//上溢
}
}

// 出栈
public int pop() {
if (!isEmpty()) {
return array[top--];
} else {
throw new RuntimeException("underflow");//下溢
}
}

// 是否为空
public boolean isEmpty() {
return top == -1 ? true : false;
}
}

队列

public class Queue {
Object[] array = new Object[4]; // 对象数组，队列最多存储3个对象
int first = 0; // 队首下标
int last = 0; // 队尾下标;指向指向即将添加的下一个元素位置

/**
* 将一个对象追加到队列尾部
* @return 队列满时返回false,否则返回true
*/
public boolean add(Object obj) {
if ((last + 1) % array.length == first) {
return false;
}
array[last] = obj;
last = (last + 1) % array.length;
return true;
}

/**
* 队列头部的第一个对象出队
* @return 出队的对象，队列空时返回null
*/
public Object remove() {
if (last == first) {
return null;
}
Object obj = array[first];
first = (first + 1) % array.length;
return obj;
}

}

单向链表

public class LinkedList {
public Node head = null;

public void add(int x) {
Node node = new Node(x, null);
Node p = head;
// 注意链表为空的时候的插入
if (head == null) {
head = node;
}
// 尾插法
else {
while (p.next != null) {
p = p.next;
}
p.next = node;
}
}
/**
* 遍历打印
*/
public void travese(Node head) {
Node p = head;
while (p != null) {
System.out.println(p.item);
p = p.next;
}
}

/*
* 元素
*/
private static class Node {
int item;
Node next;

public Node(int item, Node next) {
this.item = item;
this.next = next;
}
}
}

算法

排序

/** 冒泡排序 大数向后 */
public static void bubbleSort(int[] ary) {
for (int i = 0; i < ary.length - 1; i++) {// length-1次,最后一个不用冒了.
for (int j = 0; j < ary.length - 1 - i; j++) {
if (ary[j] > ary[j + 1]) {
int t = ary[j];    ary[j] = ary[j + 1];ary[j + 1] = t;
}
}
}
}

/**选择排序  每次选出最小的数放前面 */
public static void selectionSort(int[] ary) {
for(int i=0;i<ary.length-1;i++){
for(int j=i+1;j<ary.length;j++){
if(ary[i]>ary[j]){
int t = ary[i];    ary[i] = ary[j];ary[j] = t;
}
}
}
}

/**插入排序  */
public static void insertSort(int[] ary){
int t,i,j;
for(i=1;i<ary.length;i++){
System.out.println(Arrays.toString(ary));
t = ary[i];
for(j=i-1;j>=0&&ary[j]>t;j--){
ary[j+1] = ary[j];
}
ary[j+1] = t;
}
}

二分法查找

/*
* 二分查找 简介:在左边的数；如果搜寻的数大于所搜寻的对象，则右边的数无需再搜寻，直接搜寻左边的数。
*/
public static int search(int[] nums, int num) {
int low = 0;
int high = nums.length - 1;

while (low <= high) {
int mid = (low + high) / 2;

// 与中间值比较确定在左边还是右边区间,以调整区域
if (num > nums[mid]) {
low = mid + 1;
} else if (num < nums[mid]) {
high = mid - 1;
} else {
return mid;
}
}

return -1;
}

位运算

计算机中的数都是二进制表示的，以8位的byte类型表示为例

5 = 00000101（最高位表示符号，0位正，1为负）

无论>>还是>>>都是针对二进制数进行操作的。

1、 右移运算符>>使指定值的所有位都右移规定的次数。

右边移出去的部分扔掉不要，左边空出来的部分用原来的数字填充（这就是所谓的带符号右移）

比如说5，右移后为00000010。

你给的例子，假设x=-12，表示为32位int型就是

11111111111111111111111111110100

x>>3即带符号右移3位，结果是

11111111111111111111111111111101，化为十进制等于-3

2、>>>与>>唯一的不同是它无论原来的最左边是什么数，统统都用0填充。**

比如你的例子，byte是8位的，-1表示为byte型是11111111(补码表示法）

b>>>4就是无符号右移4位，即00001111，这样结果就是15。