weixin_37632716的博客

//扫描整个数组并返回最大的元素void FindLargestInArray(int n,int[] a){ int large = a[0]; for(int i = 0;i<=n-1;i++){ if(int i = 1;i<=n-1;i++){ if(a[i] > large){ large = a[i]; } } System.out.println("Largest"+large); }}voi

1.穷尽搜索void checkDuplicateBruteForce(int[] a,int n){ for(int i = 0;i<n;i++){ for(int j = i +1;j<n;j++){ if(a[i] == a[j]){ System.out.println("Dubplicates exist"+a[i]); } } } System.out.println("No duplicates in given

1.无序线性查找假设给定一个数组，其元素的排列顺序是未知的，数组中的元素无序，如果要查找某个元素，必须通过扫描整个数组才能实现int unSortedLineSearch(int[] a,int n,int data){ for(int i = 0;i<n;i++){ if(a[i] == data){ return i; } } return -1;}2.排序/有序线性查找如果数组的元素已经排序，则许多情况下都不需要扫描整个数组来判断元素是否在给定

quickSort(int[] a,int low,int high){ int pivot; if(high>low){ pivot = Partition(a,low,high); quickSort(a,low,pivot-1); quickSort(a,pivot+1,high); }}int partition(int[] a,int low,int high){ int left,right,pivot_item=a[low]; right

void mergeSSort(int[] a,int[] temp,int left,int right){ int mid; if(right > left){ mid = (right+left)/2; mergeSort(a,temp,left,mid); mergeSort(a.temp,mid+1,right); Merge(a,temp,left,mid+1,right); }}void merge(int[] a,int[] temp,

void shellSort(int a[],int array_size){ int h = 3*(array_size/9)+1; for(;h>0;h/3){ for(int i = h+1;i<= array_size;i++){ int v = a[i]; int j = i; while(j>h&&a[j-h]>v){ a[j] = a[j-h]; j -= h;

void insertionSort(int[] a){ for(int i = 2;i<a.length;i++){ int v = a[i]; int j = i; while(a[j-1]>a[j]){ a[j] = a[j-1]; j--; } a[j]=v; }}

void selectionSort(int a[],int n){ for(int i = 0;i< n;i++){ min = i; for(int j = i+1;j< n;j++){ if(a[j]<a[min]){ min = j; } } int temp = a[min] a[min] = a[i]; a[i] = temp; }}

void bubbleSort(int[] a,int n){ int swapped = 1; for(int pass = n-1;pass >= 0 & swapped == 1; pass --){ swapped = 0; for(int i = 0;i< pass -1;i++){ if(a[i] > a[i+1]){ int temp = a[i]; a[i] = a[i+1]; a[

void Prims(Graph g,int s){ Heap pq = new Heap(); int v,w; pq.enQueue(s); Distance[s]=0; while(!pq.isEmpty()){ v = pq.deleteMin(); for all adjacent vertices w of v{ Compute new distance d = Distance[v] + weight[v][w]; if(Distan

void dijkstra(Graph g,int s){ Heap pq = new Heap(); int v,w; pq.enQueue(s); for(int i = 0;i<G.vertexCount;i++){ Distance[i] = -1; } Distance[s] = 0; while(!pq.isEmpty()){ int v = pq.deleteMin(); for(int j =0;j< G.vertexCount

void unWeightedShortestPath(Graph G,int s){ LLQueue q = new LLQueue(); int v,w; q.enQueue(s); for(int i = 0;i<G.vertexCount;i++){ Distance[i] = -1; } Distance[s] = 0; while(!q.isEmpty()){ v = q.deQueue(); for(int j = 0;j< G.

class vertex{ public char label; public boolean visited; public Vertex(char lab){ label.= lab; visited = false; }}class graph{ private final int maxVertices = 20; private Vertex vertexList[]; private int adjMatrix[][]; private in

class Vertex{ public char label; public boolean visited; public Vertex(char lab){ this.label = lab; visited = false; }}class Graph{ private final int maxVertices = 20; private Vertex vertexList[]; private int adjMatrix[][]; priva

public class Graph{ private ArrayList<Integer> vertices; private ListNode[] edges; private int vertexCount = 0; public Graph(int vertexCount){ this.vertexCount = vertexCount; vertices = new ArrayList<>(); edges = new ListNo

public class Graph{ //邻接矩阵 private boolean adjMatrix[][]; //维度 private int vertexCount; //初始化 public Graph(int vertexCount){ this.vertxtCount = vertexCount; adjMatrix = new int[vertexCount][vertexCount]; } //加元素 public void addEdg

int delete(Heap h,int i){ int key; if(i <= -1 || i > this.count){ System.out.println("Wrong position!"); } key = h.array[i]; h.array[i] = h.array[this.count -1]; h.count--; h.percolateDown(i); return key;}

public void percolateDown(int i){ int l,r,max,temp; l = leftChild(i); r = rightChild(i); if(l != -1 && this.array[l] > this.array[i]){ max = l; }else{ max = i; } if( r != -1 && this.array[r] > this.array[max]){

1.堆的大小+12.将新元素放在堆的尾部3.从下至上堆化这个元素int insert(int data){ int i; if(this.count == this.capacity){ resizeHeap(); } this.count++; i = this.count -1; while(i >= 0 && data > this.array[(i-1)/2]){ this.array[i] = this.array[(i-1

堆的一个重要性质是，如果一个元素不满足堆的性质，那么从这个元素开始，到根节点的所有元素都存在这个问题，如果堆化该元素，从这个元素到根节点的所有元素也都满足堆的性质public void precolateDown(int i){ if(i<= -1 || i > this.count){//this.count为堆中具有的元素数 return; } int l = 0; int r = 0; int max = 0; int temp = 0; l = le

以最大堆为例public class heap{ //因为堆在形式上是完全二叉树，所以用数组表示不会浪费任何空间 public int[] array; //堆中元素的个数 public int count; //堆的大小 public int capacity; //最大堆或者最小堆 public int heap_type; public heap(int capacity,int heap_type){ this.heap_type = heap_t

public void linkLevelNodes(BinaryTreeNode root){ Queue q = new Queue(); BinaryTreeNode prev; BinaryTreeNode temp; int currentLevelNodeCount = 0; int nextLevelNodeCount = 0; if(root == null){ return; } q.enQueue(root); currentLevelNode

BinarySearchTreeNode pruneBST(BinarySearchTreeNode root,int a,int b){ if(root == null){ return null; } root.setLeft(pruneBST(root.getLeft())); root.setRight(pruneBST(root.getRight())); if(a<=root.getData() && root.getData() <= b

BinaryTreeNode removeleaf(BinaryTreeNode root){ if(root == null){ return null; } if(root.getLeft() == null && root.getRight() == null){ return null; }else{ root.setLeft(root.getLeft()); root.setRight(root.getRight()); }

半结点就是只有一个孩子的结点使用后序遍历，首先处理左孩子，然后处理右孩子，最后是结点本身，因此算法自底向上，从叶子结点到根节点来形成一棵新树，当处理到当前结点，左右子树已经处理完毕BinaryTreeNode removeHalf(BinaryTreeNode root){ if(root == null){ return null; } root.setLeft(removeHalf(root.getLeft())); root.setRight(removeHalf(root

int isAVL(BinarySearchTreeNode root){ int left = 0; int right = 0; if(root == null){ return 0; } left = isAVL(root.getLeft()); if(left == -1){ return left; } right = isAVL(root.getRight()); if(right == -1){ return right; }

AVLTreeNode insert(AVLTreeNode root,AVLTreeNode parent,int data){ if(root == null){ root = new AVLTreeNode(); root.setData(data); root.setLeft(null); root.setRight(null); root.setHeight(0); } else if(data < root.getData()){

LLAVLTreeNode singleRotateLeft(AVLTreeNode X){ AVLTreeNode W = X.getLeft(); X.setLeft(W.getRight()); W.serRight(X); X.setHeight(Math.max(Height(X.getLeft()),Height(X.getRight()))+1); W.setHeight(Math.max(Height(W.getLeft()),Height(W.getRight()))

1.AVL树是一颗二叉搜索树，具有二叉搜索树的性质2.对任意结点X,其左子树的高度与其右子树的高度的差不超过一AVL树的定义public class AVLTreeNode{ private int data; private int height; private AVLTreeNode left; private AVLTreeNode right; public int getData(){ return this.data; } public void

递归void rangePrinter(BinarySearchTreeNode root,int k2,int k2){ if(root == null){ return null; } if(root.getData() >= k1){ rangePrinter(root.getLeft(),k1,k2); } if(root.getData() >= k1 && root.getData() <= k2){ System.

利用中序遍历产生有序表，在中序遍历BST树时，记录已访问的节点个数BinarySearchTreeNode kthNode(BinarySearchTreeNode root,int k,int count){ if(root == null){ return null; } BinarySearchTreeNode left = kthNode(root.getLeft,k,count); if(left != null){ return left; } if(+

int length(ListNode node){ int count = 0; if(node == null){ return count; }else{ count++; } while(node.getNext() != null){ count++; node = node.getNext(); } return count;}BinaryTreeNode sortedListToBST(listNode node){ ret

如果需要从数组中选择一个元素作为平衡二叉搜索树的根节点，应该选择有序数组的中间元素，在每次迭代中，选择有序数组的中间元素作为子树的根节点，然后以这个元素构建树的一个节点，当该选择元素后，分成两个数组，一个位于该元素的左边，另一个位于该元素的右边，这两个数组就是原始问题的子问题，因为它们都是有序的，而且，是当前节点的左子树和右子树，所以，可以采用分治法实现BinaryTreeNode buildBST(int A[],int left,int right){ BinaryTreeNode newNode

对于每个节点，需要检查其左子树的最大值是否小于当前节点的值，右子树的最小值是否小于该节点的值boolean isBST(BinaryTreeNode root){ if(root == null){ reutrn true; } if(root.getLeft() != null && findMax(root.getLeft()) > root.getData()){ return false; } if(root.getRight() != n

根据二叉搜索树的性质，当从根节点到底部遍历这颗BST树时候，假设两个节点的值为a,b,如果存在一个节点的值介于a b之间，其中的第一个节点就是其最近的公共祖先LCA，如果大于a b,则节点位于该节点的左侧，反之，在右侧BinarySearchTreeNode findLCA(BinarySearchTreeNode root,BinarySearchTreeNode a,BinarySearchTreeNode b){ while(true){ if(a.getData() < root

删除操作有三种情况（1）如果待删除元素为叶子节点，则返回null给双亲节点，将其相应的孩子节点指针设置为null(2) 如果待删除节点有一个孩子节点，通常在这种情况下，只需要将删除节点的孩子节点返回给双亲节点(3) 如果待删除元素有两个孩子节点，通常的做法是从左子树中找到最大的元素来代替原节点的值BinarySearchNode findMax(BinaryTreeNode root){ if(root == null){ return null; } else{

在二叉搜索树中插入数据，首先需要找到插入该数据的位置，遵循与寻找操作相同的机制，就能够找到插入的位置，当找到插入位置时，如果该数据已经存在，那么只需要忽略并且返回，否则，将该数据插入走过的路径的最后位置上BinarySearchTreeNode insert(BinarySearchTreeNode root,int data){ if(root == null){ root = new BinarySearchTreeNode(); if(root == null){

递归BinaryTreeNode findMax(BinaryTreeNode root){ if(root == null){ return null; } else{ if(root.getRight() == null){ return root; } else{ return findMax(root.getRight()); } }}非递归BinaryTreeNode findMax(BinaryTreeNo

递归BinarySearchTreeNode findMin(BinaryTreeNode root){ if(root == null){ return null; } else{ if(root.getLeft() == null) return root; else return findMin(root.getLeft()); }}非递归BinarySearchTreeNode findMin(BinaryTreeNode r

思路二叉搜索树的寻找操作简单有效，从根节点开始，基于二叉搜索树的性质移动到左子树或右子树继续搜索，如果待搜索数据与节点数据一致，则返回当前结点，如果待搜索数据小于根节点数据，则搜索当前结点的左子树，否则，搜索当前结点的右子树，如果数据不存在，则返沪一个空指针代码递归：BinarySearchTreeNode find(BinarySearchTreeNode root,int data){ if(root == null) return null; if(data > root