Data structure basics - Java Implementation

  • Stack & Queue Implementations
  1. FixedCapacityQueue
  2. FixedCapacityStack
  3. ResizingArrayQueue
  4. ResizingArrayStack
  5. LinkedListQueue

  6. LinkedListStack
    1.   
  • Basic Sorting Algorithm Implementations

  1. 复制代码
    package cn.edu.tsinghua.stat.mid_term;
    
    /**
     * Created by shuaiyi on 04/11/2017.
     */
    public class InsertionSort {
        private void swap(Comparable[] a, int i, int j) {
            Comparable tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    
        private static boolean less(Comparable v, Comparable w) {
            return v.compareTo(w) < 0;
        }
    
        private void sort(Comparable[] a) {
            for (int i = 1; i < a.length; ++i) {
                for (int j = i; j > 0 && less(a[j], a[j - 1]); --j) {
                    swap(a, j, j - 1);
                }
            }
        }
    
        public static void main(String[] args) {
            InsertionSort insertionSort = new InsertionSort();
    
            String[] a = new String[]{"54", "23", "98", "67", "12", "32", "23", "55", "98", "94"};
    
            insertionSort.sort(a);
    
            for (String item :
                    a) {
                System.out.print(item + ", ");
            }
        }
    }
    InsertionSort
    复制代码
  2.  

  3. 复制代码
    package cn.edu.tsinghua.stat.mid_term;
    
    import static java.lang.Math.min;
    
    /**
     * Created by shuaiyi on 04/11/2017.
     */
    public class SelectionSort {
    
        private void swap(Comparable[] a, int i, int j) {
            Comparable tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    
        private void sort(Comparable[] a) {
            int i, j;
            for (i = 0; i < a.length; ++i) {
                int curMinIndex = i;
                for (j = i + 1; j < a.length; ++j) {
                    if (less(a[j], a[curMinIndex])) {
                        curMinIndex = j;
                    }
                }
    
                if (curMinIndex != i) {
                    swap(a, i, curMinIndex);
                }
            }
        }
    
        private static boolean less(Comparable v, Comparable w) {
            return v.compareTo(w) < 0;
        }
    
        public static void main(String[] args) {
            SelectionSort selectionSort = new SelectionSort();
    
            String[] a = new String[]{"54", "23", "98", "67", "12", "32", "23", "55", "98", "94"};
    
            selectionSort.sort(a);
    
            for (String item :
                    a) {
                System.out.print(item + ", ");
            }
        }
    
    }
    SelectionSort
    复制代码

     

  4. 复制代码
    package cn.edu.tsinghua.stat.mid_term;
    
    /**
     * Created by shuaiyi on 04/11/2017.
     */
    public class MergeSort {
    
        private Comparable[] aux;
    
        public MergeSort(int cap) {
            aux = new Comparable[cap];
        }
    
        private void swap(Comparable[] a, int i, int j) {
            Comparable tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    
        private static boolean less(Comparable v, Comparable w) {
            return v.compareTo(w) < 0;
        }
    
        private void sort(Comparable[] a) {
            sort(a, 0, a.length - 1);
        }
    
        private void sort(Comparable[] a, int low, int high) {
            if (low >= high) {
                return;
            }
            int mid = (low + high) / 2;
            sort(a, low, mid);
            sort(a, mid + 1, high);
            merge(a, low, high);
        }
    
        private void merge(Comparable[] a, int low, int high) {
            int mid = (low + high) / 2;
            int lft_index = low;
            int right_index = mid + 1;
    
            for (int k = low; k <= high; ++k) {
                this.aux[k] = a[k];
            }
    
            int flag = lft_index;
            while(lft_index <= mid && right_index <= high) {
                if (less(this.aux[lft_index], this.aux[right_index])) {
                    a[flag++] = this.aux[lft_index++];
                } else {
                    a[flag++] = this.aux[right_index++];
                }
            }
    
            while(lft_index <= mid) {
                a[flag++] = this.aux[lft_index++];
            }
    
            while(right_index <= high) {
                a[flag++] = this.aux[right_index++];
            }
        }
    
        private void officialMerge(Comparable[] a, int low, int high) {
            int mid = (low + high) / 2;
            int i = low;
            int j = mid + 1;
    
            for (int k = low; k <= high; ++k) {
                this.aux[k] = a[k];
            }
    
            for (int k = low; k <= high; ++k) {
                if (i > mid) {
                    a[k] = this.aux[j++];
                } else if (j > high) {
                    a[k] = this.aux[i++];
                } else if (less(this.aux[j], this.aux[i])) {
                    a[k] = this.aux[j++];
                } else {
                    a[k] = this.aux[i++];
                }
            }
        }
    
        public static void main(String[] args) {
    
            String[] a = new String[]{"8", "3", "1", "4", "6", "5", "9", "7", "2", "0"};
    
            MergeSort mergeSort = new MergeSort(a.length);
    
            mergeSort.sort(a);
    
            for (String item :
                    a) {
                System.out.print(item + ", ");
            }
        }
    }
    MergeSort
    复制代码

     

  5. 复制代码
    package cn.edu.tsinghua.stat.mid_term;
    
    /**
     * Created by shuaiyi on 04/11/2017.
     */
    public class QuickSort {
        private void swap(Comparable[] a, int i, int j) {
            Comparable tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    
        private static boolean less(Comparable v, Comparable w) {
            return v.compareTo(w) < 0;
        }
    
    
        private void sort(Comparable[] a) {
            sort(a, 0, a.length - 1);
        }
    
        private void sort(Comparable[] a, int lft, int rht) {
            if (lft >= rht) {
                return;
            }
            int mid = partition(a, lft, rht);
            sort(a, lft, mid);
            sort(a, mid + 1, rht);
        }
    
        private int partition(Comparable[] a, int lft, int rht) {
            int mid = (lft + rht) / 2;
            int cnt = 0;
            for (int k = lft; k <= rht; ++k) {
                if (less(a[k], a[mid])) {
                    ++cnt;
                }
            }
    
            if (cnt + lft != mid) {
                swap(a, cnt + lft, mid);
            }
    
            mid = cnt + lft;
            int less_index = lft;
            int more_index = mid + 1;
            while (less_index < mid && more_index <= rht) {
                if (less(a[less_index], a[mid])) {
                    less_index++;
                } else{
                    swap(a, less_index, more_index);
                    more_index++;
                }
            }
    
            return mid;
        }
    
        private int officalPartition(Comparable[] a, int lo, int hi) {
            int i = lo, j = hi + 1;
            Comparable v = a[lo];
            while (true) {
                while (less(a[++i], v)) if (i == hi) break;
                while (less(v, a[--j])) if (j == lo) break;
                if (i >= j) break;
                swap(a, i, j);
            }
    
            swap(a, lo, j);
            return j;
        }
    
        public static void main(String[] args) {
    
            String[] a = new String[]{"8", "3", "1", "4", "6", "5", "9", "7", "2", "0"};
    
            QuickSort quickSort = new QuickSort();
    
            quickSort.sort(a);
    
            for (String item :
                    a) {
                System.out.print(item + ", ");
            }
        }
    }
    QuickSort
    复制代码

     

  6. 复制代码
    package cn.edu.tsinghua.stat.mid_term;
    
    /**
     * Created by shuaiyi on 04/11/2017.
     */
    public class MaxPQ<T extends Comparable<T>> {
    
        private int N = 0;
        private T[] pq;
    
        MaxPQ(int cap) {
            this.pq = (T[]) new Comparable[cap + 1];
        }
    
        public void insert(T item) {
            this.pq[++N] = item;
            swim(N);
        }
    
        public T delMax() {
            T maxNode = this.pq[1];
            swap(this.pq, 1, N);
            this.pq[N] = null;
            N--;
            sink(1);
            return maxNode;
        }
    
        public void swap(Comparable[] a, int i, int j) {
            Comparable tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    
        public static boolean less(Comparable v, Comparable w) {
            return v.compareTo(w) < 0;
        }
    
        public void swim(int k) {
            while(k > 1 && less(this.pq[k / 2], this.pq[k])) {
                swap(this.pq, k/2, k);
                k /= 2;
            }
        }
    
        public void sink(int k) {
            while(k * 2 <= N) {
                int child = k * 2;
                if (child + 1 <= N && less(this.pq[child], this.pq[child + 1])) {
                    child = k * 2 + 1;
                }
                if (less(this.pq[k], this.pq[child])) {
                    swap(this.pq, k, child);
                    k = child;
                } else {
                    break;
                }
            }
        }
    
        public void officialSink(int k) {
            while(2 * k <=N) {
                int j = 2 * k;
                if (j < N && less(pq[j], pq[j + 1])) j++;
                if (!less(pq[k], pq[j])) break;
                swap(pq, k, j);
                k = j;
            }
        }
    
        public String[] sort() {
            String[] res = new String[this.N];
            int flag = 0;
            while (N > 0) {
                res[flag++] = (String)delMax();
            }
            return res;
        }
    
        public static void main(String[] args) {
    
            String[] a = new String[]{"8", "3", "1", "4", "6", "5", "9", "7", "2", "0"};
    
            MaxPQ<String> maxPQ = new MaxPQ<>(a.length);
    
            for (String s :
                    a) {
                maxPQ.insert(s);
            }
    
            String[]b  = maxPQ.sort();
    
            for (String item :
                    b) {
                System.out.print(item + ", ");
            }
        }
    }
    MaxPQ
    复制代码

       

posted @   Jeremy Wu  阅读(235)  评论(0编辑  收藏  举报
点击右上角即可分享
微信分享提示