Sorting

 

  1 package  dwq.algo.sort;
  2
  3 import  java.util.Arrays;
  4
  5 public   class  Sorting
  6 {
  7
  8    public static void main(String[] args)
  9    {
 10        // int []a = {2,1, 3, 5, 4};
 11        //        
 12        // bubbleSort(a);
 13        // System.out.println( Arrays.toString(a));
 14        // //Integer []b = {7,1, 3, 5, 4};
 15        // //
 16        Integer[] b = { 11, 8, 4, 7 };
 17        insertSort(b, b.length);
 18
 19        System.out.println(Arrays.toString(b));
 20
 21        int[] c = { 2, 1, 3, 2, 5, 4, 2, 3, 3, 4, 5, 6 ,-10, 110};// 12
 22        heapSort(c);
 23
 24        System.out.println("heap sort " + Arrays.toString(c));
 25
 26        int[] re = const2ElemSum(c, 3);
 27        if (re.length == 2)
 28            System.out.println(Arrays.toString(re));
 29
 30        int[] a = { 1, 2, 3, 8, 5, 9, 17 };
 31        int re2 = const2ElemSum2(a, 8);
 32        System.out.println(re2);
 33    }
 34
 35    /** *//**
 36     * 
 37     * @param a
 38     * @param x
 39     * @return :int[2]:i,j when a[i] + a[j] == x
 40     */
 41    static int[] const2ElemSum(int[] a, int x)
 42    {
 43        quickSort(a);
 44        int sum = 0;
 45        for (int i = 0, j = a.length - 1; i < j;)
 46        {
 47            sum = a[i] + a[j];
 48            if (sum == x) return new int[] { a[i], a[j] };
 49            else if (x > sum) i++;
 50            else j--;
 51        }
 52        return new int[] {};
 53    }
 54
 55    /** *//**
 56     * 题目条件：a是一个集合的元素，则各数不同。则可正确统计出存在两数为和的对数 利用了原理：若a, x-a存在于集合中则条件满
 57
 58足。所以
 59     * 
 60     * @param a
 61     * @param x
 62     * @return
 63     */
 64    static int const2ElemSum2(int[] a, int x)
 65    {
 66        // int []b = new int[a.length];
 67        int[] c = new int[2 * a.length];
 68        for (int i = 0; i < a.length; i++)
 69        {
 70            c[i] = a[i];
 71            // b[i] = x - a[i];
 72            c[a.length + i] = x - a[i];
 73        }
 74        quickSort(c);
 75        int count = 0;
 76        for (int i = 1, tmp = c[0]; i < c.length; i++)
 77        {
 78            if (tmp == c[i])
 79            {
 80                count++;
 81                if (i < c.length - 1)
 82                    tmp = c[++i];// tmp设置为i的下一个
 83            } else tmp = c[i];
 84        }
 85        return count / 2;
 86    }
 87
 88    /** *//**
 89     * 严蔚敏书上的冒泡排序算法，有利用交换与否进行改进
 90     * 
 91     * @param a
 92     */
 93    static void bubbleSort(int[] a)
 94    {
 95        boolean change = true;
 96        for (int i = a.length - 1; i > 0 && change; i--)// i > 0即可因为i =
 97        // 1时有二个元素比较过了。一个无需比较
 98        {
 99            for (int j = 0; j < i; j++)
100            {
101                change = false;
102                if (a[j] > a[j + 1])
103                {
104                    change = true;
105                    a[j] = a[j] + a[j + 1] - (a[j + 1] = a[j]);
106                }
107            }
108        }
109    }
110
111    static void quickSort(int[] a)
112    {
113        System.out.println(" call my QS");
114        quickSort(a, 0, a.length - 1);
115    }
116
117    static void quickSort(int[] a, int left, int right)
118    {
119        if (left < right) // 这里是if, 给写成了while
120        {
121            // int j = partition(a, left, right);
122            int pivot = a[left];
123            int i = left;
124            int j = right + 1;
125            while (true)// 一定是true, 使用break退出的
126            {
127                while (i < right && a[++i] <= pivot)
128                    ;
129                while (j > left && a[--j] >= pivot)
130                    ; // a[left] end it.
131                // 错误代码：每次i都必然会++的，但是这显然不对
132                // while( a[++i] <= pivot | a[--j] >= pivot) if(j <= i) break;
133                if (j <= i) break; // 这里也必须有相等，否则对2,1排不了，因为其实本身这时交换就没有意义了,=出
134
135现在一个到头时
136                a[j] = a[j] + a[i] - (a[i] = a[j]);
137            }
138            a[j] = a[j] + a[left] - (a[left] = a[j]);
139            quickSort(a, left, j - 1);
140            quickSort(a, j + 1, right);
141        }
142    }
143
144    /** *//**
145     * 1、最后pivot位置确定:pivot 取在第一个，为从后到前指针交流，取最后一个话，与从前到后指针交换 2、对等号的有无，
146     * 应该有，这样可以跳过与pivot相等，移动快一次
147     * 
148     * @param a
149     * @param left
150     * @param right
151     * @return
152     */
153    static int partition(int a[], int left, int right)
154    {
155        int pivot = a[left];
156        int i = left;
157        int j = right + 1;
158        while (true)// 一定是true, 使用break退出的
159        {
160            while (i < right && a[++i] <= pivot)
161                ;
162            while (j > left && a[--j] >= pivot)
163                ; // a[left] end it.
164            if (i >= j)
165                break;
166            a[j] = a[j] + a[i] - (a[i] = a[j]);
167        }
168        a[j] = a[j] + a[left] - (a[left] = a[j]);
169        return j;
170    }
171
172    static <T extends Comparable<T>> void quickSort(T[] data)
173    {
174        quickSort(data, 0, data.length - 1);
175    }
176
177    private static <T extends Comparable<T>> void quickSort(T[] data, int left,
178            int right)
179    {
180        if (left + 10 <= right)
181        {
182            T pivot = middle3(data, left, right);// 执行三数中值分割法， pivot =
183            // data[last]
184            int i = left, j = right - 1;
185            for (;;)
186            {
187                while (data[++i].compareTo(pivot) < 0)
188                {
189                }
190                while (data[--j].compareTo(pivot) > 0)
191                {
192                }
193                if (i < j)
194                {
195                    swap(data, i, j);
196                } else
197                {
198                    break;
199                }
200            }
201            swap(data, i, right - 1);
202            quickSort(data, left, i - 1);
203            quickSort(data, i + 1, right);
204        } else
205        {
206            System.out.println("insertionSort() in Quicksort");
207            insertionSort(data);
208        }
209    }
210
211    private static <T extends Comparable<T>> T middle3(T[] data, int left,
212            int right)
213    {
214        int center = (left + right) / 2;
215        if (data[center].compareTo(data[left]) < 0)
216        {
217            swap(data, left, center);
218        }
219        if (data[right].compareTo(data[left]) < 0)
220        {
221            swap(data, left, right);
222        }
223        if (data[right].compareTo(data[center]) < 0)
224        {
225            swap(data, center, right);
226        }
227        swap(data, center, right - 1); // 取中元素最后放到了末尾
228        return data[right - 1];
229    }
230
231    private static <T extends Comparable<T>> void swap(T[] data, int i, int j)
232    {
233        T temp = data[i];
234        data[i] = data[j];
235        data[j] = temp;
236    }
237
238    // 插入排序;
239    public static <T extends Comparable<T>> void insertionSort(T[] data)
240    {
241        System.out.println("insertSort() ");
242        int j;
243        for (int p = 1; p < data.length; p++)
244        {
245            T temp = data[p];
246            for (j = p; j > 0 && temp.compareTo(data[j - 1]) < 0; j--)
247            {
248                data[j] = data[j - 1];
249            }
250            data[j] = temp;
251        }
252    }
253
254    public static <T extends Comparable<T>> void insertSort(T[] data, int n)
255    {
256        if (n == 1) return;
257        insertSort(data, n - 1);
258        int j;
259        for (int p = 1; p < n; p++)
260        {
261            T temp = data[p];
262            for (j = p; j > 0 && temp.compareTo(data[j - 1]) < 0; j--)
263            {
264                data[j] = data[j - 1];
265            }
266            data[j] = temp;
267        }
268    }
269
270    static void heapSort(int[] a)
271    {
272        //builder the heap
273        int size = a.length;
274        for(int i = (size-1)/2; i >= 0;i--)
275            maxHeapity(a, i, size);
276        // for i= size - 2, exchagne to last
277        for(int i = size -1;i > 0;i--)
278        {
279            a[0] = a[0] + a[i] - ( a[i] = a[0]);
280            size -= 1;
281            maxHeapity(a, 0, size);
282        }
283    }
284
285    static void maxHeapity(int[] a, int i, int size)
286    {
287        int left = (i << 1) + 1; // i * 2 + 1,当下标从0正式开始时
288        int right = (i << 1) + 2;
289        int t;
290        if ( left<size && a[left]>a[i] ) t = left;
291        else t = i;
292        if (right < size && a[right] > a[t])
293            t = right;
294        if( t != i)
295        {
296            a[t] = a[i] + a[t] - ( a[i] = a[t]);
297            maxHeapity(a, t, size);
298        }
299    }
300}
301