数据结构
1、链表
由不定数量的节点(Node)组成，每个节点仅知道下一个结点的位置，且向外仅仅暴露头(head)，一切操作直接或者间接从头开始；
代码：单向链表的实现、链表反转、链表中间点查询、链表排序
1.1单向链表的实现
1 // 链表的实现 2 public class Test { 3 public static void main(String[] args) { 4 NodeManager nodeManager = new NodeManager(); 5 nodeManager.addNode("大"); 6 nodeManager.addNode("家"); 7 nodeManager.addNode("好"); 8 nodeManager.addNode("才"); 9 nodeManager.addNode("是"); 10 nodeManager.addNode("真"); 11 nodeManager.addNode("的"); 12 nodeManager.delNode("好"); 13 nodeManager.print(); 14 } 15 } 16 //节点管理类--封装的增删改 17 class NodeManager { 18 19 private Node root;//根节点 20 21 //添加节点 22 public void addNode(String data) { 23 if (root == null) { 24 root = new Node(data); 25 } else { 26 root.addNode(data); 27 } 28 } 29 //删除节点 30 public void delNode (String data) { 31 if (root.data.equals(data)){ 32 root = root.next; 33 } else { 34 root.delNode(data); 35 } 36 } 37 //打印节点 38 public void print() { 39 if (root != null) { 40 System.out.print(root.data + " ->"); 41 root.print(); 42 } 43 } 44 45 46 47 // 节点类--节点结构和自带简易方法 48 class Node { 49 private String data;//数据源 50 private Node next;//指针域 51 52 public Node(String data) { 53 this.data = data; 54 } 55 //添加方法 56 public void addNode(String data) { 57 if (this.next == null) { 58 this.next = new Node(data); 59 } else { 60 this.next.addNode(data); 61 } 62 } 63 //删除方法 64 public void delNode(String name) { 65 if (this.next != null) { 66 if (this.next.data.equals(name)) { 67 this.next = this.next.next; 68 } else { 69 this.next.delNode(name); 70 } 71 } 72 } 73 //打印方法 74 public void print() { 75 if (this.next != null) { 76 System.out.print(this.next.data + "->"); 77 this.next.print(); 78 } 79 } 80 } 81 }
1.2链表反转
1 /** 2 * 链表反转 3 * 4 * @param head 5 * @return 6 */ 7 public Node ReverseIteratively(Node head) { 8 Node pReversedHead = head; 9 Node pNode = head; 10 Node pPrev = null; 11 while (pNode != null) { 12 Node pNext = pNode.next; 13 if (pNext == null) { 14 pReversedHead = pNode; 15 } 16 pNode.next = pPrev; 17 pPrev = pNode; 18 pNode = pNext; 19 } 20 this.head = pReversedHead; 21 return this.head; 22 }
1.3链表中间点查询
1 /** 2 * 查找单链表的中间节点 3 * 采用快慢指针的方式查找单链表的中间节点，快指针一次走两步，慢指针一次走一步，当快指针走完时，慢指针刚好到达中间节点 4 * @param head 5 * @return 6 */ 7 public Node SearchMid(Node head) { 8 Node p = this.head, q = this.head; 9 while (p != null && p.next != null && p.next.next != null) { 10 p = p.next.next; 11 q = q.next; 12 } 13 System.out.println("Mid:" + q.data); 14 return q; 15 }
1.4链表排序
1 /** 2 * 排序 3 * 用当前的node和随后的所有的比较并进行位置互换，一波后挪一个节点 4 * @return 5 */ 6 public Node orderList() { 7 Node nextNode = null; 8 int tmp = 0; 9 Node curNode = head; 10 while (curNode.next != null) { 11 nextNode = curNode.next; 12 while (nextNode != null) { 13 if (curNode.data > nextNode.data) { 14 tmp = curNode.data; 15 curNode.data = nextNode.data; 16 nextNode.data = tmp; 17 } 18 nextNode = nextNode.next; 19 } 20 curNode = curNode.next; 21 } 22 return head; 23 }
2、队列与栈
栈：数据只能在栈的一端即栈顶位置进行插入和删除操作；先进后出，后进先出
队列：数据只能在队列的一端插入并在另一端进行删除操作；先进先出
代码：栈的实现、队列的实现
2.1栈的实现
1 //栈的实现push和pop 2 public void push(T data) { 3 if (data==null){ 4 throw new StackException("data can't be null"); 5 } 6 if(this.top==null){ 7 //调用pop()后top可能为null 8 this.top=new Node<T>(data); 9 }else if(this.top.data==null){ 10 this.top.data=data; 11 }else { 12 Node<T> p=new Node<T>(data,this.top); 13 top=p; 14 //更新栈顶 15 } 16 size++; 17 } 18 public T pop() { 19 if(isEmpty()){ 20 throw new EmptyStackException("Stack empty"); 21 } 22 23 T data=top.data; 24 top=top.next; 25 size--; 26 return data; 27 }
2.2队列实现
1 /** 2 * 队列入队算法 3 * @param data 4 * @author WWX 5 */ 6 public void enqueue(T data){ 7 //创建一个节点 8 Node s=new Node(data,null); 9 //将队尾指针指向新加入的节点，将s节点插入队尾 10 rear.next=s; 11 rear=s; 12 size++; 13 } 14 15 /** 16 * 队列出队算法 17 * @return 18 * @author WWX 19 */ 20 public T dequeue(){ 21 if(rear==front){ 22 try { 23 throw new Exception("堆栈为空"); 24 } catch (Exception e) { 25 e.printStackTrace(); 26 } 27 return null; 28 }else{ 29 //暂存队头元素 30 Node p=front.next; 31 T x=p.data; 32 //将队头元素所在节点摘链 33 front.next=p.next; 34 //判断出队列长度是否为1 35 if(p.next==null) 36 rear=front; 37 //删除节点 38 p=null; 39 size--; 40 return x; 41 } 42 }
3、二叉树
二叉树：N个结点构成的有限集合；每个结点至多只有两棵子树（即二叉树中不存在度大于2的结点），并且，二叉树的子树有左右之分，其次序不能任意颠倒。
特性： (1)若根结点的层次为1，则二叉树第i层最多有2i−1(i≥1)个结点；在高度为h的二叉树中，最多有2h−1个结点（h≥0）；
(2)满二叉树和完全二叉树
(3) 一棵具有n个结点的完全二叉树，对于序号为i(0≤i＜n)的结点，则有如下规则
①若i=0，则i为根结点，无父母结点；若i>0，则i的父母结点序号为⌊i−12⌋(向下取整)。
②若2i+1＜n,则i的左孩子结点序号为2i+1，否则i无左孩子。
③若2i+2＞n,则i的右孩子结点序号为2i+2，否则i无右孩子。
代码：二叉树实现、遍历
3.1二叉树实现
1 // 二叉树数据结构的实现 2 public class Test { 3 public static void main(String[] args) { 4 BinaryTreeManger binaryTreeManger = new BinaryTreeManger(); 5 6 binaryTreeManger.add(1); 7 binaryTreeManger.add(3); 8 binaryTreeManger.add(4); 9 binaryTreeManger.add(8); 10 binaryTreeManger.add(6); 11 binaryTreeManger.print(); 12 } 13 } 14 15 class BinaryTreeManger{ 16 17 private Node root;//根节点 18 19 public void add(int data) { 20 if (root == null) { 21 root = new Node(data); 22 } else { 23 root.addNode(data); 24 } 25 } 26 public void print() { 27 root.print(); 28 } 29 class Node{ 30 private int data; 31 private Node left; //左子树 32 private Node right; //右子树 33 34 public Node(int data) { 35 this.data = data; 36 } 37 //添加节点 38 public void addNode(int data) { 39 //首先判断大小，来决定将data放在那个子树上 40 if (data > this.data){//当前数据较大，放在右子树 41 if (this.right == null) { 42 this.right = new Node(data); 43 } else { 44 this.right.addNode(data); 45 } 46 } else { //较小放在左子树上 47 if (this.left == null) { 48 this.left = new Node(data); 49 } else { 50 this.left.addNode(data); 51 } 52 53 } 54 55 } 56 //中序遍历 左 -> 根 -> 右 57 public void print() { 58 if (this.left != null) { 59 this.left.print(); 60 } 61 System.out.print(data); 62 if (this.right != null) { 63 this.right.print(); 64 } 65 } 66 } 67 }
3.2二叉树遍历
1 public void visted(TreeNode subTree){ 2 subTree.isVisted=true; 3 System.out.println("key:"+subTree.key+"--name:"+subTree.data);; 4 } 5 //前序遍历 6 public void preOrder(TreeNode subTree){ 7 if(subTree!=null){ 8 visted(subTree); 9 preOrder(subTree.leftChild); 10 preOrder(subTree.rightChild); 11 } 12 } 13 14 //中序遍历 15 public void inOrder(TreeNode subTree){ 16 if(subTree!=null){ 17 inOrder(subTree.leftChild); 18 visted(subTree); 19 inOrder(subTree.rightChild); 20 } 21 } 22 23 //后续遍历 24 public void postOrder(TreeNode subTree) { 25 if (subTree != null) { 26 postOrder(subTree.leftChild); 27 postOrder(subTree.rightChild); 28 visted(subTree); 29 } 30 } 31 32 //前序遍历的非递归实现 33 public void nonRecPreOrder(TreeNode p){ 34 Stack<TreeNode> stack=new Stack<TreeNode>(); 35 TreeNode node=p; 36 while(node!=null||stack.size()>0){ 37 while(node!=null){ 38 visted(node); 39 stack.push(node); 40 node=node.leftChild; 41 } 42 while(stack.size()>0){ 43 node=stack.pop(); 44 node=node.rightChild; 45 } 46 } 47 } 48 49 //中序遍历的非递归实现 50 public void nonRecInOrder(TreeNode p){ 51 Stack<TreeNode> stack =new Stack<BinaryTree.TreeNode>(); 52 TreeNode node =p; 53 while(node!=null||stack.size()>0){ 54 //存在左子树 55 while(node!=null){ 56 stack.push(node); 57 node=node.leftChild; 58 } 59 //栈非空 60 if(stack.size()>0){ 61 node=stack.pop(); 62 visted(node); 63 node=node.rightChild; 64 } 65 } 66 } 67 68 //后序遍历的非递归实现 69 public void noRecPostOrder(TreeNode p){ 70 Stack<TreeNode> stack=new Stack<BinaryTree.TreeNode>(); 71 TreeNode node =p; 72 while(p!=null){ 73 //左子树入栈 74 for(;p.leftChild!=null;p=p.leftChild){ 75 stack.push(p); 76 } 77 //当前结点无右子树或右子树已经输出 78 while(p!=null&&(p.rightChild==null||p.rightChild==node)){ 79 visted(p); 80 //纪录上一个已输出结点 81 node =p; 82 if(stack.empty()) 83 return; 84 p=stack.pop(); 85 } 86 //处理右子树 87 stack.push(p); 88 p=p.rightChild; 89 } 90 }
借鉴博客(版权已被声明)：http://blog.csdn.net/javazejian/article/details/53727333
4、其他
串：若干个字符组成的有限序列；
数组：有限个类型相同的变量的集合；
广义表：若干个元素组成的有限序列；
排序算法
各种排序算法时间复杂度和空间复杂度
1、插入排序
插入排序：稳定，最好最坏均为O(n2)；
原理：拿要后边要排序元素与前边已经排好的元素进行比较，从后向前扫描，找到位置并插入；
shell排序：不稳定，平均O(n1.5)，最坏O(n2)；
原理：数据等距离分组，组内插入排序；分组距离减半，组内继续插入排序....
1.1插入排序
1 for (int i = 0; i < len; i++) { 2 for (int j = i + 1; j < len && j > 0; j--) { 3 if (a[j] < a[j - 1]) { 4 int temp = a[j]; 5 a[j] = a[j - 1]; 6 a[j - 1] = temp; 7 } 8 } 9 }
1.2shell排序
1 int group, i, j, temp,len; 2 len = unsorted.length; 3 for (group = len / 2; group > 0; group /= 2) 4 { 5 for (i = group; i < len; i++) 6 { 7 for (j = i - group; j >= 0; j -= group) 8 { 9 if (unsorted[j] > unsorted[j + group]) 10 { 11 temp = unsorted[j]; 12 unsorted[j] = unsorted[j + group]; 13 unsorted[j + group] = temp; 14 } 15 } 16 } 17 }
2、选择排序
直接选择：不稳定，最好最坏均为O(n2)；
原理：每次从当前位置到最末尾，获取最小数据互换到当前位置，并依次后移
堆排序：不稳定，最好最坏均为O(nlog2n)；
原理：完全二叉树，大顶堆(父节点大于等于子节点)，小顶堆(父节点小于等于子节点)；
数据构建完全二叉树->大顶堆->根节点换到叶子节点左右侧(把最大数据放到最后)->大顶堆->根节点换到叶子节点左右侧(再次把第二大数据放到最后第二位置)....
2.1直接选择
1 //min 记录最小数据，index记录最小位置 2 int min = 0; 3 int index = 0; 4 int len = a.length; 5 for (int i = 0; i < len - 1; i++) { 6 min = a[i]; 7 index = i; 8 for (int j = i + 1; j < len; j++) { 9 if (a[j] < min) { 10 min = a[j]; 11 index = j; 12 } 13 } 14 a[index] = a[i]; 15 a[i] = min; 16 }
2.2堆排序
1 //调整堆 2 void HeapAdjust(int *a,int i,int size) 3 { 4 int lchild=2*i; //i的左孩子节点序号 5 int rchild=2*i+1; //i的右孩子节点序号 6 int max=i; //临时变量 7 if(i<=size/2) //如果i是叶节点就不用进行调整 8 { 9 if(lchild<=size&&a[lchild]>a[max]) 10 { 11 max=lchild; 12 } 13 if(rchild<=size&&a[rchild]>a[max]) 14 { 15 max=rchild; 16 } 17 if(max!=i) 18 { 19 swap(a[i],a[max]); 20 HeapAdjust(a,max,size); //避免调整之后以max为父节点的子树不是堆 21 } 22 } 23 } 24 void BuildHeap(int *a,int size) //建立堆 25 { 26 int i; 27 for(i=size/2;i>=1;i--) //非叶节点最大序号值为size/2 28 { 29 HeapAdjust(a,i,size); 30 } 31 } 32 void HeapSort(int *a,int size) //堆排序 33 { 34 int i; 35 BuildHeap(a,size); 36 for(i=size;i>=1;i--) 37 { 38 swap(a[1],a[i]); //交换堆顶和最后一个元素，即每次将剩余元素中的最大者放到最后面 39 HeapAdjust(a,1,i-1); //重新调整堆顶节点成为大顶堆 40 } 41 }
3、交换排序
冒泡排序：稳定，平均最坏均为O(n2)；
原理：重复走访数据，每加入一次数据，从该位置起，相邻数据两两比较，位置互换；
快速排序：不稳定，平均为O(nlog2n)，最坏为O(n2)；
原理：将数据分隔成两部分，左边<key<右边，依次递归，缩小范围
3.1冒泡排序
1 //j与j+1相邻比较 2 for(int i = 0; i < len-1; i++){ 3 for (int j = 0; j > len-i; j++){ 4 if (array[j] < array[j+1] ){ 5 swap(array,j,j+1); 6 } 7 } 8 }
3.2快速排序
1 public void sort(int[] a,int low,int high){ 2 int start = low; 3 int end = high; 4 int key = a[low]; 5 6 7 while(end>start){ 8 //从后往前比较 9 //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较 10 while(end>start&&a[end]>=key) 11 end--; 12 if(a[end]<=key){ 13 int temp = a[end]; 14 a[end] = a[start]; 15 a[start] = temp; 16 } 17 //从前往后比较 18 //如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置 19 while(end>start&&a[start]<=key) 20 start++; 21 if(a[start]>=key){ 22 int temp = a[start]; 23 a[start] = a[end]; 24 a[end] = temp; 25 } 26 //此时第一次循环比较结束，关键值的位置已经确定了。 27 //左边的值都比关键值小，右边的值都比关键值大， 28 //但是两边的顺序还有可能是不一样的，进行下面的递归调用 29 } 30 //递归 31 if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1 32 if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个 33 }
4、归并排序
5、基数排序
平均O(n3/2)，最坏O(n2)