1 package edu.princeton.cs.algs4; 2 /****************************************************************************** 3 * Compilation: javac Insertion.java 4 * Execution: java Insertion < input.txt 5 * Dependencies: StdOut.java StdIn.java 6 * Data files: http://algs4.cs.princeton.edu/21elementary/tiny.txt 7 * http://algs4.cs.princeton.edu/21elementary/words3.txt 8 * 9 * Sorts a sequence of strings from standard input using insertion sort. 10 * 11 * % more tiny.txt 12 * S O R T E X A M P L E 13 * 14 * % java Insertion < tiny.txt 15 * A E E L M O P R S T X [ one string per line ] 16 * 17 * % more words3.txt 18 * bed bug dad yes zoo ... all bad yet 19 * 20 * % java Insertion < words3.txt 21 * all bad bed bug dad ... yes yet zoo [ one string per line ] 22 * 23 ******************************************************************************/ 24 25 26 27 import java.util.Comparator; 28 29 /** 30 * The {@code Insertion} class provides static methods for sorting an 31 * array using insertion sort. 32 * <p> 33 * This implementation makes ~ 1/2 n^2 compares and exchanges in 34 * the worst case, so it is not suitable for sorting large arbitrary arrays. 35 * More precisely, the number of exchanges is exactly equal to the number 36 * of inversions. So, for example, it sorts a partially-sorted array 37 * in linear time. 38 * <p> 39 * The sorting algorithm is stable and uses O(1) extra memory. 40 * <p> 41 * See <a href="http://algs4.cs.princeton.edu/21elementary/InsertionPedantic.java.html">InsertionPedantic.java</a> 42 * for a version that eliminates the compiler warning. 43 * <p> 44 * For additional documentation, see <a href="http://algs4.cs.princeton.edu/21elementary">Section 2.1</a> of 45 * <i>Algorithms, 4th Edition</i> by Robert Sedgewick and Kevin Wayne. 46 * 47 * @author Robert Sedgewick 48 * @author Kevin Wayne 49 */ 50 public class Insertion { 51 52 // This class should not be instantiated. 53 private Insertion() { } 54 55 /** 56 * Rearranges the array in ascending order, using the natural order. 57 * @param a the array to be sorted 58 */ 59 public static void sort(Comparable[] a) { 60 int n = a.length; 61 for (int i = 0; i < n; i++) { 62 for (int j = i; j > 0 && less(a[j], a[j-1]); j--) { 63 exch(a, j, j-1); 64 } 65 assert isSorted(a, 0, i); 66 } 67 assert isSorted(a); 68 } 69 70 /** 71 * Rearranges the subarray a[lo..hi) in ascending order, using the natural order. 72 * @param a the array to be sorted 73 * @param lo left endpoint (inclusive) 74 * @param hi right endpoint (exclusive) 75 */ 76 public static void sort(Comparable[] a, int lo, int hi) { 77 for (int i = lo; i < hi; i++) { 78 for (int j = i; j > lo && less(a[j], a[j-1]); j--) { 79 exch(a, j, j-1); 80 } 81 } 82 assert isSorted(a, lo, hi); 83 } 84 85 /** 86 * Rearranges the array in ascending order, using a comparator. 87 * @param a the array 88 * @param comparator the comparator specifying the order 89 */ 90 public static void sort(Object[] a, Comparator comparator) { 91 int n = a.length; 92 for (int i = 0; i < n; i++) { 93 for (int j = i; j > 0 && less(a[j], a[j-1], comparator); j--) { 94 exch(a, j, j-1); 95 } 96 assert isSorted(a, 0, i, comparator); 97 } 98 assert isSorted(a, comparator); 99 } 100 101 /** 102 * Rearranges the subarray a[lo..hi) in ascending order, using a comparator. 103 * @param a the array 104 * @param lo left endpoint (inclusive) 105 * @param hi right endpoint (exclusive) 106 * @param comparator the comparator specifying the order 107 */ 108 public static void sort(Object[] a, int lo, int hi, Comparator comparator) { 109 for (int i = lo; i < hi; i++) { 110 for (int j = i; j > lo && less(a[j], a[j-1], comparator); j--) { 111 exch(a, j, j-1); 112 } 113 } 114 assert isSorted(a, lo, hi, comparator); 115 } 116 117 118 // return a permutation that gives the elements in a[] in ascending order 119 // do not change the original array a[] 120 /** 121 * Returns a permutation that gives the elements in the array in ascending order. 122 * @param a the array 123 * @return a permutation {@code p[]} such that {@code a[p[0]]}, {@code a[p[1]]}, 124 * ..., {@code a[p[n-1]]} are in ascending order 125 */ 126 public static int[] indexSort(Comparable[] a) { 127 int n = a.length; 128 int[] index = new int[n]; 129 for (int i = 0; i < n; i++) 130 index[i] = i; 131 132 for (int i = 0; i < n; i++) 133 for (int j = i; j > 0 && less(a[index[j]], a[index[j-1]]); j--) 134 exch(index, j, j-1); 135 136 return index; 137 } 138 139 /*************************************************************************** 140 * Helper sorting functions. 141 ***************************************************************************/ 142 143 // is v < w ? 144 private static boolean less(Comparable v, Comparable w) { 145 return v.compareTo(w) < 0;//若v为a w为b则 v.compareTo(w) < 0为真 因为a为97 b为98 146 } //即a[j]=a，a[j-1]=b也就是b在a的前面则考虑互换位置 147 148 // is v < w ? 149 private static boolean less(Object v, Object w, Comparator comparator) { 150 return comparator.compare(v, w) < 0; 151 } 152 153 // exchange a[i] and a[j] 154 private static void exch(Object[] a, int i, int j) { 155 Object swap = a[i]; 156 a[i] = a[j]; 157 a[j] = swap; 158 } 159 160 // exchange a[i] and a[j] (for indirect sort) 161 private static void exch(int[] a, int i, int j) { 162 int swap = a[i]; 163 a[i] = a[j]; 164 a[j] = swap; 165 } 166 167 /*************************************************************************** 168 * Check if array is sorted - useful for debugging. 169 ***************************************************************************/ 170 private static boolean isSorted(Comparable[] a) { 171 return isSorted(a, 0, a.length); 172 } 173 174 // is the array a[lo..hi) sorted 175 private static boolean isSorted(Comparable[] a, int lo, int hi) { 176 for (int i = lo+1; i < hi; i++) 177 if (less(a[i], a[i-1])) return false; 178 return true; 179 } 180 181 private static boolean isSorted(Object[] a, Comparator comparator) { 182 return isSorted(a, 0, a.length, comparator); 183 } 184 185 // is the array a[lo..hi) sorted 186 private static boolean isSorted(Object[] a, int lo, int hi, Comparator comparator) { 187 for (int i = lo+1; i < hi; i++) 188 if (less(a[i], a[i-1], comparator)) return false; 189 return true; 190 } 191 192 // print array to standard output 193 private static void show(Comparable[] a) { 194 for (int i = 0; i < a.length; i++) { 195 StdOut.println(a[i]); 196 } 197 } 198 199 /** 200 * Reads in a sequence of strings from standard input; insertion sorts them; 201 * and prints them to standard output in ascending order. 202 * 203 * @param args the command-line arguments 204 */ 205 public static void main(String[] args) { 206 String[] a = StdIn.readAllStrings(); 207 Insertion.sort(a); 208 show(a); 209 } 210 } 211 212 /****************************************************************************** 213 * Copyright 2002-2016, Robert Sedgewick and Kevin Wayne. 214 * 215 * This file is part of algs4.jar, which accompanies the textbook 216 * 217 * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne, 218 * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X. 219 * http://algs4.cs.princeton.edu 220 * 221 * 222 * algs4.jar is free software: you can redistribute it and/or modify 223 * it under the terms of the GNU General Public License as published by 224 * the Free Software Foundation, either version 3 of the License, or 225 * (at your option) any later version. 226 * 227 * algs4.jar is distributed in the hope that it will be useful, 228 * but WITHOUT ANY WARRANTY; without even the implied warranty of 229 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 230 * GNU General Public License for more details. 231 * 232 * You should have received a copy of the GNU General Public License 233 * along with algs4.jar. If not, see http://www.gnu.org/licenses. 234 ******************************************************************************/