队列
队列是一种特殊的线性表,特殊之处在于它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。
代码实现:
public class Queue{
private Object[] objects;
private int size;
private int head;
private int end;
public Queue(int size){
this.objects = new Object[size];
this.head = 0;
this.end = 0;
this.size = 0;
}
//插入操作
public void push(Object object) throw Exception{
if(this.size >objects.length)
throw new Exception("Queue is Full");
objects[end++] = object;
size++;
}
//删除操作
public Object pop() throws Exception{
if(this.size == 0)
throw new Exception("Queue is empty!")
if(head == Objects.length)
this.head = 0;
size--;
return objects[head++];
}
//查看对头
public Object peek() throws Exception{
if(this.size == 0)
throw new Exception("Queue is empty");
return objects[head];
}
public boolean isEmpty(){
return size == 0;
}
public boolean isFull(){
return size == objects.length;
}
public int getSize() {
return size;
}
}
栈
栈(stack)又名堆栈,它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈,它是把新元素放到栈顶元素的上面,使之成为新的栈顶元素;从一个栈删除元素又称作出栈或退栈,它是把栈顶元素删除掉,使其相邻的元素成为新的栈顶元素。
代码实现:
public class Stack(){
private Object[] objects;
private int head;
private int size;
public Stack(int size){
objects = new Object[size];
this.head = 0;
this.size = 0;
}
//入栈操作
public void push(Object object) throw Exception{
if(this.size == objects.length)
throw new Exception("this stack is full");
objects[head++] = object;
size++;
}
//出栈操作
public Object pop() throws Exception{
if(size == 0)
throw new Exception("this stack is empty");
size--;
return objects[--head];
}
}
冒泡排序
- 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤,除了最后一个。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
代码实现:
public class BubbleSort {
public static void main(String[] args) {
//举个栗子
int[] a ={1,4,7,8,2,6};
//从第一个循环到倒数第二个数,都进行内循环的操作
for (int i=0;i<a.length-1;i++) {
//从第一个循环到倒数第二个依次跟后一位比较,每次循环都将最小的元素放到最后面,由于最后的是最小的,所以下次循环不予考虑,故依次循环减少
for(int j=0;j<a.length-i-1;j++){
if(a[j]<a[j+1]){
int temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
for(int i=0;i<a.length;i++){
System.out.print(a[i]+" ");
}
}
}
快速排序
基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
代码实现:
public class QuickSort {
public static int middle(int[] array, int left, int right) {
int temp = array[left];
while (left != right) {
while (right > left && array[right] > temp)
right--;
array[left] = array[right];
while (right > left && array[left] < temp)
left++;
array[right] = array[left];
}
array[right] = temp;
return right;
}
public static int[] sort(int[] a, int left, int right) {
if (left < right) {
int i = middle(a, left, right);
sort(a, left, i);
sort(a, i + 1, right);
}
return a;
}
//测试
public static void main(String[] args) {
int[] a = {11, 81, 27, 53, 42, 45, 6, 77, 178, 9, 70};
sort(a, 0, a.length - 1);
for (int i : a) {
System.out.print(i+" ");
}
}
}
斐波那契数列
非递归方法:
public class Feibonaqie {
public static int feibo(int n){
int p=1,q=1;
if(n==1||n==2)
return 1;
for(int i=3;i<=n;i++){
int tmp =p;
p=q;
q=tmp+q;
}
return q;
}
}
递归方法:
public static int f(int n){
if(n <= 0)
return 0;
if(n ==1||n== 2)
return 1;
return f(n-1)+f(n-2);
}