添加 shell排序

.metadata/.plugins/com.aptana.core.io/connections.18

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<connections/>

.metadata/.plugins/com.aptana.syncing.core/defaultConnection.18

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<connection>
+<connection>
+<name>Default</name>
+<source>file:/home/junv</source>
+</connection>
+</connection>

.metadata/.plugins/com.aptana.syncing.core/sites.18

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<sites/>

.metadata/.plugins/com.aptana.webserver.core/webservers.18

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<servers/>

.metadata/.plugins/org.eclipse.core.resources/.history/0/d0517815fdfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20,1,6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		//首先进行分组
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			//对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+				
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/10/c05ac8ddf5fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0 ; i <len-d; i++) {
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/10/c08a5786fcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int outer = gap; outer < length; outer++) {
+				
+
+				for (j = outer; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/11/b0b54f8cfcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int outer = gap; outer < length; outer++) {
+				
+
+				for (int inner = outer; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/15/70560c69eefb001111d9e4c22bd86da6

@@ -0,0 +1,14 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+	
+	// 定义需要排序的数组
+	private static int[] array = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 };
+
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/15/903c0773fcfb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				
+
+				for (j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+				//data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/15/a05b1310fcfb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        int length = data.length;
+        for(int gap = length / 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < length; i++){  
+                int temp = data[i];
+                
+                for(j = i; j >= gap && temp<data[j - gap]; j= j-gap){  
+                	
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/17/204ccb32fcfb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				int temp = data[i];
+
+				for (j = i; j >= gap && data[i] < data[j - gap]; j = j - gap) {
+
+					data[j] = data[j - gap];
+				}
+
+				data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/17/20c6cf2dfbfb001111d9e4c22bd86da6

@@ -0,0 +1,32 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < data.length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j= j-gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+               // data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/18/e0dec72ff6fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0 ; i <len-d; i++) {
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/19/7016a0a1f8fb001111d9e4c22bd86da6

@@ -0,0 +1,39 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i <len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                	System.out.println("array["+(i+d)+"]"+array[i+d]+"****array["+i+"]"+array[i]);
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1a/c0e81f0bf7fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i < len; i=i+d) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/1d/7008831bfffb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 1, 6, 3, 19, 7, 14, 5, 60, 29, 40 };
+
+	public static void shellSort(int[] data) {
+		//获取数组长度
+		int length = data.length;
+		// 首先进行分组,每次组中元素大致为之前2倍。
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			// 对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+				
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j
+						- gap) {
+					//缓存下表最大的那个数
+					int temp = data[j];
+					//将两数交换位置，将较大数保存到下标最大的位置。
+					data[j] = data[j - gap];
+					data[j - gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2/50f9933cf7fb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i < len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+            
+            
+            for(int temp : array){
+            	
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/20/106444fbf8fb001111d9e4c22bd86da6

@@ -0,0 +1,40 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d/ 2);  
+            
+            for (int i = 0; i <len-d; i++) {  
+            	System.out.println("array["+(i+d)+"]="+array[i+d]+" array["+i+"]="+array[i]);
+                if (array[i+d].compareTo(array[i]) < 0) {  	
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/21/50fdadf4f8fb001111d9e4c22bd86da6

@@ -0,0 +1,40 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d/ 2);  
+            
+            for (int i = 0; i <len-d; i++) {  
+            	System.out.println("array["+(i+d)+"]="+array[i+d]+"****array["+i+"]="+array[i]+"***");
+                if (array[i+d].compareTo(array[i]) < 0) {  	
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/21/709e38e2fbfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				int temp = data[i];
+
+				for (j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+
+					data[j] = data[j - gap];
+				}
+
+				data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/22/d024fa5feffb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/23/7059c95cfefb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 1, 6, 3, 19, 7, 14, 5, 60, 29, 40 };
+
+	public static void shellSort(int[] data) {
+
+		int length = data.length;
+		// 首先进行分组,每次所分组为之前2倍。
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			// 对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+				
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j
+						- gap) {
+					//缓存下表最大的那个数
+					int temp = data[j];
+					//将两数交换位置，将较大数保存到下标最大的位置。
+					data[j] = data[j - gap];
+					data[j - gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/24/90c17a18ebfb001111d9e4c22bd86da6

@@ -0,0 +1,13 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/25/d081342bfbfb001111d9e4c22bd86da6

@@ -0,0 +1,32 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < data.length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j= j-gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/26/009caf61fafb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 };
+
+	public static void shellSort(Comparable[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap /= 2){  
+            for(int i = gap; i < data.length; i++){  
+                Comparable temp = data[i];  
+                for(j = i; j >= gap && temp.compareTo(data[j - gap]) < 0; j -= gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+        
+       
+          
+        shellSort(data);  
+        System.out.println();  
+          
+        for(int i = 0; i < data.length; i++)  
+            System.out.print(data[i] + " ");  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/28/60aa2ec9fafb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 };
+
+	public static void shellSort(int[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap = gap / 2){  
+            for(int i = gap; i < data.length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j -= gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/28/e0894bcaebfb001111d9e4c22bd86da6

@@ -0,0 +1,14 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+	
+	// 定义需要排序的数组
+	private static int[] array = { 16, 20, 6, 3, 19, 7, 14, 5, 10 };
+
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2c/c00eb2a9fafb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 };
+
+	public static void shellSort(int[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap /= 2){  
+            for(int i = gap; i < data.length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j -= gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+        
+       
+          
+        shellSort(data);  
+        System.out.println();  
+          
+        for(int i = 0; i < data.length; i++)  
+            System.out.print(data[i] + " ");  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2d/b03df1f2eefb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d > 1) {  
+        	System.out.println("d========"+d);
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2e/6071c8b0eefb001111d9e4c22bd86da6

@@ -0,0 +1,29 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array, int len) {  
+        int d = len;  
+        while (d > 1) {  
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12, 10,8};  
+        Another.shellSort(testArray, 10);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2f/80671202f7fb001111d9e4c22bd86da6

@@ -0,0 +1,47 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >=1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+				
+				for (int i = 0; i < len - d; i++) {
+					if (array[i + d].compareTo(array[i]) < 0) {
+						T temp = array[i + d];
+						array[i + d] = array[i];
+						array[i] = temp;
+					}
+				}
+			} else {
+				d=(d+1)/2;
+				
+				for (int i = 0; i < len - (d+1); i++) {
+					if (array[i + d].compareTo(array[i]) < 0) {
+						T temp = array[i + d];
+						array[i + d] = array[i];
+						array[i] = temp;
+					}
+				}
+			}
+
+			
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/2f/90c32cd6f6fb001111d9e4c22bd86da6

@@ -0,0 +1,47 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+				
+				for (int i = 0; i < len - d; i++) {
+					if (array[i + d].compareTo(array[i]) < 0) {
+						T temp = array[i + d];
+						array[i + d] = array[i];
+						array[i] = temp;
+					}
+				}
+			} else {
+				d=(d+1)/2;
+				
+				for (int i = 0; i < len - d-1; i++) {
+					if (array[i + d].compareTo(array[i]) < 0) {
+						T temp = array[i + d];
+						array[i + d] = array[i];
+						array[i] = temp;
+					}
+				}
+			}
+
+			
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/30/80c7695ff6fb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+        	if(d%2 ==0){
+        		d =(d  / 2); 
+        	}
+             
+            for (int i = 0 ; i <len-d; i++) {
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/33/900df582f6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2;
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/33/908019fffbfb001111d9e4c22bd86da6

@@ -0,0 +1,35 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        int length = data.length;
+        for(int gap = length / 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < length; i++){  
+                int temp = data[i];
+                
+                for(j = i; j >= gap && temp<(data[j - gap]); j= j-gap){  
+                	
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/35/f08105b8fafb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 };
+
+	public static void shellSort(int[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap /= 2){  
+            for(int i = gap; i < data.length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j -= gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/37/d0540c85f6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >=1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2;
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/38/80288f7cfdfb001111d9e4c22bd86da6

@@ -0,0 +1,13 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+	
+	// 定义需要排序的数组
+	private static int[] array = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 };
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/39/e024389ffdfb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 1, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+
+		int length = data.length;
+		// 首先进行分组
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			// 对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j
+						- gap) {
+
+					int temp = data[j];
+					data[j] = data[j - gap];
+
+					data[j - gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/3d/003d2d79f6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d > 1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2;
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/3f/607a6a67fbfb001111d9e4c22bd86da6

@@ -0,0 +1,35 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        int length = data.length;
+        for(int gap = length / 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < length; i++){  
+                int temp = data[i];
+                
+                for(j = i; j >= gap && temp<(data[j - gap]); j= j-gap){  
+                	
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/40/2077adc2ebfb001111d9e4c22bd86da6

@@ -0,0 +1,14 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+	
+	// 定义需要排序的数组
+	private static int[] array = { 16, 20, 6, 3, 19, 7, 14, 12, 10 };
+
+	
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/40/807d0796f8fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i <len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+              
+            }  
+            
+            System.out.println("****************************");
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/40/c0cf5e64f5fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i < len; i=i+d) {  
+                if (array[i].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/47/6071366feffb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4a/801053f8f8fb001111d9e4c22bd86da6

@@ -0,0 +1,40 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d/ 2);  
+            
+            for (int i = 0; i <len-d; i++) {  
+            	System.out.println("array["+(i+d)+"]="+array[i+d]+"****array["+i+"]="+array[i]);
+                if (array[i+d].compareTo(array[i]) < 0) {  	
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4c/70881b43f6fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0 ; i <len-d; i++) {
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4c/c0b7f29ffcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int outer = gap; outer < length; outer++) {
+				
+
+				for (int inner = outer; inner >= gap && data[inner] < data[inner- gap]; inner = inner- gap) {
+					
+					int temp = data[inner];
+					data[inner] = data[inner - gap];
+					
+					data[inner-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/4f/f06b05d0eefb001111d9e4c22bd86da6

@@ -0,0 +1,30 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d > 1) {  
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12, 10};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/51/d0fe0de7fcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20,1， 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		//首先进行分组
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			//对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+				
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/52/903a56dbfbfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				int temp = data[i];
+
+				for (j = i; j >= gap && data[i] < data[j - gap]; j = j - gap) {
+
+					data[j] = data[j - gap];
+				}
+
+				data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/54/0012b379fafb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 };
+
+	public static void shellSort(int[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap /= 2){  
+            for(int i = gap; i < data.length; i++){  
+                Comparable temp = data[i];  
+                for(j = i; j >= gap && temp.compareTo(data[j - gap]) < 0; j -= gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+        
+       
+          
+        shellSort(data);  
+        System.out.println();  
+          
+        for(int i = 0; i < data.length; i++)  
+            System.out.print(data[i] + " ");  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/56/60ef98b7f8fb001111d9e4c22bd86da6

@@ -0,0 +1,39 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i <len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                	System.out.println("array["+(i+d)+"]"+array[i+d]+"****array["+i+"]"+array[i]+"***");
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/57/00a1bb27f6fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0 ; i <len-d; i++) {
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/59/406768effdfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 1, 6, 3, 19, 7, 14, 5, 60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+
+		int length = data.length;
+		// 首先进行分组
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			// 对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j
+						- gap) {
+
+					int temp = data[j];
+					data[j] = data[j - gap];
+
+					data[j - gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5a/5066579ff5fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0 ; i <=len-d; i=i+d) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5b/30a5370df7fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i < len-d; i=i+d) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5f/709c739bf5fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0 ; i < len; i=i+d) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/5f/d0f24652fbfb001111d9e4c22bd86da6

@@ -0,0 +1,33 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        int length = data.length;
+        for(int gap = length / 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j= j-gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6/508ee22efefb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 1, 6, 3, 19, 7, 14, 5, 60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+
+		int length = data.length;
+		// 首先进行分组,每次所分组为之前2倍。
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			// 对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+				
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j
+						- gap) {
+					//缓存下表最大的那个数
+					int temp = data[j];
+					//将较大数保存到下标最大的位置。
+					data[j] = data[j - gap];
+					data[j - gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/60/1092a280f6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >= 1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2;
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/60/90dee6c7eefb001111d9e4c22bd86da6

@@ -0,0 +1,30 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d > 1) {  
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12, 10,8};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/62/d03cf3e5f8fb001111d9e4c22bd86da6

@@ -0,0 +1,40 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d/ 2);  
+            
+            for (int i = 0; i <len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                	
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/64/c0cc9e43f7fb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i < len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/68/70de0b42fcfb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				int temp = data[i];
+
+				for (j = i; j >= gap && data[i] < data[j - gap]; j = j - gap) {
+
+					data[j] = data[j - gap];
+				}
+
+				data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/69/60c2774efbfb001111d9e4c22bd86da6

@@ -0,0 +1,33 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        int length = data.length;
+        for(int gap = length/ 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < data.length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j= j-gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6b/407deb1efefb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 1, 6, 3, 19, 7, 14, 5, 60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+
+		int length = data.length;
+		// 首先进行分组,每次所分组为之前2倍。
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			// 对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j
+						- gap) {
+					//缓存下表最大的那个数
+					int temp = data[j];
+					
+					data[j] = data[j - gap];
+					data[j - gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6b/b08dc8f5fbfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				int temp = data[i];
+
+				for (j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+
+					data[j] = data[j - gap];
+				}
+
+				data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6e/b043c0caf6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2;
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/6f/10b0bc4efafb001111d9e4c22bd86da6

@@ -0,0 +1,38 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+
+	public static void shellSort(Comparable[] data){  
+        int j;  
+        for(int gap = data.length / 2; gap > 0; gap /= 2){  
+            for(int i = gap; i < data.length; i++){  
+                Comparable temp = data[i];  
+                for(j = i; j >= gap && temp.compareTo(data[j - gap]) < 0; j -= gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+        Random r = new Random();  
+        Comparable[] data = new Comparable[20];  
+        for(int i = 0; i < data.length; i++){  
+            data[i] = r.nextInt(data.length);  
+        }  
+          
+        for(int i = 0; i < data.length; i++)  
+            System.out.print(data[i] + " ");  
+          
+        shellSort(data);  
+        System.out.println();  
+          
+        for(int i = 0; i < data.length; i++)  
+            System.out.print(data[i] + " ");  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/73/905b9316f9fb001111d9e4c22bd86da6

@@ -0,0 +1,40 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d/ 2);  
+            
+            for (int i = 0; i <len-d; i++) {  
+            	System.out.println("array["+(i+d)+"]="+array[i+d]+"    array["+i+"]="+array[i]);
+                if (array[i+d].compareTo(array[i]) < 0) {  	
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    System.out.println("array["+(i+d)+"]="+array[i+d]+"    array["+i+"]="+array[i]);
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/74/505067c0eefb001111d9e4c22bd86da6

@@ -0,0 +1,30 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = a;  
+        while (d > 1) {  
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12, 10,8};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/74/506ac693fcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int outer = gap; outer < length; outer++) {
+				
+
+				for (int inner = outer; inner >= gap && data[inner] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/75/80f7bf55fcfb001111d9e4c22bd86da6

@@ -0,0 +1,34 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				int temp = data[i];
+
+				for (j = i; j >= gap && temp < data[j - gap]; j = j - gap) {
+
+					data[j] = data[j - gap];
+				}
+
+				data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/75/c0397673f6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >= 1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/76/2082afcdfbfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				int temp = data[i];
+
+				for (j = i; j >= gap && data[i] < (data[j - gap]); j = j - gap) {
+
+					data[j] = data[j - gap];
+				}
+
+				data[j] = temp;
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/76/b0a54ef1f8fb001111d9e4c22bd86da6

@@ -0,0 +1,40 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d/ 2);  
+            
+            for (int i = 0; i <len-d; i++) {  
+            	System.out.println("array["+(i+d)+"]"+array[i+d]+"****array["+i+"]"+array[i]+"***");
+                if (array[i+d].compareTo(array[i]) < 0) {  	
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/77/c07a40adfcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				
+
+				for (j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/78/10c40f2ef5fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/79/e0daed84f7fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i < len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+                System.out.println("执行次数为："+(len-d));
+            }  
+            
+            System.out.println("****************************");
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7a/509a2412fafb001111d9e4c22bd86da6

@@ -0,0 +1,40 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d/ 2);  
+            
+            for (int i = 0; i <len-d; i++) {  
+            	System.out.println("array["+(i+d)+"]="+array[i+d]+"    array["+i+"]="+array[i]);
+                if (array[i+d].compareTo(array[i]) < 0) {  	
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                    
+                }  
+              
+            }  
+            
+            
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7b/00169b87f6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >=1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2;
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7c/f0152ebdfcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				
+
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7d/10f5509bfcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int outer = gap; outer < length; outer++) {
+				
+
+				for (int inner = outer; inner >= gap && data[inner] < data[inner- gap]; inner = inner- gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7e/105dbca9fcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int outer = gap; outer < length; outer++) {
+
+				for (int inner = outer; inner >= gap
+						&& data[inner] < data[inner - gap]; inner = inner - gap) {
+
+					int temp = data[inner];
+					data[inner] = data[inner - gap];
+
+					data[inner - gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/7e/401e7f74f6fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {
+		int len = array.length;
+		int d = len;
+		while (d >= 1) {
+			System.out.println("d========" + d);
+			if (d % 2 == 0) {
+				d = (d / 2);
+			} else {
+				d=(d+1)/2;
+			}
+
+			for (int i = 0; i < len - d; i++) {
+				if (array[i + d].compareTo(array[i]) < 0) {
+					T temp = array[i + d];
+					array[i + d] = array[i];
+					array[i] = temp;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		Integer[] testArray = { 1, 20, 6, 3, 19, 7, 14, 12, 70, 18, 40, 30, 25,
+				29 };
+		Another.shellSort(testArray);
+		System.out.println("The result is:");
+		for (Integer item : testArray) {
+			System.out.print(item);
+			System.out.print(' ');
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/8/70a237e3fcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20,1， 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		//首先进行分组
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+			//对每个组进行插入比较
+			for (int i = gap; i < length; i++) {
+				
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/81/909181c1fcfb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		
+		int length = data.length;
+		//首先进行分组
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int i = gap; i < length; i++) {
+				
+
+				for (int j = i; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/83/f0dc521aebfb001111d9e4c22bd86da6

@@ -0,0 +1,16 @@
+package com.toozhao.sort;
+
+public class ShellSort {
+	
+	// 定义需要排序的数组
+		private static int[] array = { 1, 20, 6, 3, 19, 7, 14, 12, 10 };
+
+	/**
+	 * @param args
+	 */
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/86/10abb579effb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/86/6093be40fbfb001111d9e4c22bd86da6

@@ -0,0 +1,33 @@
+package com.toozhao.sort;
+
+import java.util.Random;
+
+public class Another {
+	// 定义需要排序的数组
+		private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10,9 ,80,70,60,29,30,40};
+
+	public static void shellSort(int[] data){  
+        int j;  
+        int length = data.length;
+        for(int gap = data.length / 2; gap > 0; gap = gap / 2){  
+        	
+            for(int i = gap; i < data.length; i++){  
+                int temp = data[i];  
+                for(j = i; j >= gap && temp<(data[j - gap]); j= j-gap){  
+                    data[j] = data[j - gap];  
+                }  
+                  
+                data[j] = temp;  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args){  
+         
+        shellSort(data);  
+        for(int flag :data){
+        	System.out.print(flag+" ");
+        }
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/87/4068c668f8fb001111d9e4c22bd86da6

@@ -0,0 +1,37 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i = 0; i <len-d; i++) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+                System.out.println("执行次数为："+(len-d));
+            }  
+            
+            System.out.println("****************************");
+            for(T temp : array){
+            	System.out.print(temp  +" ");
+            }
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/88/f0d63d88fcfb001111d9e4c22bd86da6

@@ -0,0 +1,36 @@
+package com.toozhao.sort;
+
+public class Another {
+	// 定义需要排序的数组
+	private static int[] data = { 16, 20, 6, 3, 19, 7, 14, 5, 10, 9, 80, 70,
+			60, 29, 30, 40 };
+
+	public static void shellSort(int[] data) {
+		int j;
+		int length = data.length;
+		for (int gap = length / 2; gap > 0; gap = gap / 2) {
+
+			for (int outer = gap; outer < length; outer++) {
+				
+
+				for (int inner = outer; j >= gap && data[j] < data[j - gap]; j = j - gap) {
+					
+					int temp = data[j];
+					data[j] = data[j - gap];
+					
+					data[j-gap] = temp;
+				}
+
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+
+		shellSort(data);
+		for (int flag : data) {
+			System.out.print(flag + " ");
+		}
+	}
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/89/104e3c8bf5fb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >=1) {  
+        	System.out.println("d========"+d);
+            d = (int)(d  / 2);  
+            for (int i =0; i < len; i=i+d) {  
+                if (array[i+d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29,11,21};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}

.metadata/.plugins/org.eclipse.core.resources/.history/89/505d5c3beffb001111d9e4c22bd86da6

@@ -0,0 +1,31 @@
+package com.toozhao.sort;
+
+public class Another {
+
+	public static <T extends Comparable<? super T>> void shellSort(T[] array) {  
+		int len = array.length;
+        int d = len;  
+        while (d >1) {  
+        	System.out.println("d========"+d);
+            d = (d + 1) / 2;  
+            for (int i = 0; i < len - d; i++) {  
+                if (array[i + d].compareTo(array[i]) < 0) {  
+                    T temp = array[i + d];  
+                    array[i + d] = array[i];  
+                    array[i] = temp;  
+                }  
+            }  
+        }  
+    }  
+      
+    public static void main(String[] args) {  
+        Integer[] testArray = {1, 20, 6, 3, 19, 7, 14, 12,70,18,40,30,25,29};  
+        Another.shellSort(testArray);  
+        System.out.println("The result is:");  
+        for (Integer item : testArray) {  
+            System.out.print(item);  
+            System.out.print(' ');  
+        }  
+    }  
+
+}