线性排序的实现

java 代码

 

1. /** 
2.  * 线性表 
3.  */  
4. package line;  
5.   
6. /** 
7.  * @author sumbeam 
8.  *  
9.  */  
10. public class LineSort {  
11.   
12.     // 数据结构  
13.     private int data[];  
14.   
15.     // 最大容量  
16.     private int maxSize;  
17.   
18.     // 实际容量  
19.     private int size;  
20.   
21.     public LineSort(int maxSize) {  
22.   
23.         this.maxSize = maxSize;  
24.         data = new int[maxSize];  
25.         size = 0;  
26.     }  
27.   
28.     /** 
29.      * 查找某数据的位置 
30.      *  
31.      * @param data 
32.      *            数据 
33.      * @return 位置 
34.      */  
35.     public int inStr(int data) {  
36.         for (int i = 0; i < this.data.length; i++) {  
37.             if (this.data[i] == data)  
38.                 return i;  
39.         }  
40.         return -1;  
41.     }  
42.   
43.     /** 
44.      * 判断是否到达最后一位 
45.      *  
46.      * @return 是否已满 
47.      */  
48.     public boolean isEnd() {  
49.         return size == maxSize;  
50.     }  
51.   
52.     /** 
53.      * 判断数据是否为空 
54.      *  
55.      * @return 是否为空 
56.      */  
57.     public boolean isEmpty() {  
58.         return size == 0;  
59.     }  
60.   
61.     /** 
62.      * 在老数据前增加一个新的数据 
63.      *  
64.      * @param oldData 
65.      *            老数据 
66.      * @param newData 
67.      *            新数据 
68.      * @return 是否成功 
69.      */  
70.     public boolean add(int oldData, int newData) {  
71.   
72.         int p = inStr(oldData);  
73.         if (p != -1)  
74.             return insert(newData, p);  
75.         return false;  
76.     }  
77.   
78.     /** 
79.      * 将数据插入在第一位 
80.      *  
81.      * @param data 
82.      *            要插入的数据 
83.      * @return 是否成功 
84.      */  
85.     public boolean addFirst(int data) {  
86.   
87.         return insert(data, 0);  
88.     }  
89.   
90.     /** 
91.      * 定义一个插入数据的方法 
92.      *  
93.      * @param data 
94.      *            要插入的数据 
95.      * @param p 
96.      *            要插入的位置 
97.      * @return 是否插入成功 
98.      */  
99.     public boolean insert(int data, int p) {  
100.         if (isEnd()) {  
101.             System.out.println("数据已满!");  
102.             return false;  
103.         }  
104.         for (int i = (size - 1); i >= p; i--) {  
105.             this.data[i + 1] = this.data[i];  
106.         }  
107.         this.size++;  
108.         this.data[p] = data;  
109.         return true;  
110.     }  
111.   
112.     /** 
113.      * 在最后一位插入一个数据 
114.      *  
115.      * @param data 
116.      *            要插入的数据 
117.      * @return 是否成功 
118.      */  
119.     public boolean addLast(int data) {  
120.         return insert(data, size);  
121.     }  
122.   
123.     /** 
124.      * 先移除一个数据 
125.      *  
126.      * @param data 
127.      *            要删除的数据 
128.      * @return 是否成功 
129.      */  
130.     public boolean remove(int data) {  
131.         if (isEmpty()) {  
132.             System.out.println("数据是空的!");  
133.             return false;  
134.         }  
135.         int p = inStr(data);  
136.         if (p != -1) {  
137.             for (int i = p; i < size; i++) {  
138.                 this.data[i] = this.data[i + 1];  
139.             }  
140.             size--;  
141.             return true;  
142.         }  
143.         return false;  
144.     }  
145.   
146.     /** 
147.      * 修改数据 
148.      *  
149.      * @param olddata 
150.      *            要被修改的数据 
151.      * @param newdata 
152.      *            修改后的数据 
153.      * @return 是否修改成功 
154.      */  
155.     public boolean updata(int olddata, int newdata) {  
156.         int p = inStr(olddata);  
157.         if (p != -1) {  
158.             this.data[p] = newdata;  
159.             return true;  
160.         }  
161.         return false;  
162.     }  
163.   
164.     /** 
165.      * 显示所有数据 
166.      */  
167.     public void display() {  
168.         for (int i = 0; i < size; i++) {  
169.             System.out.println(this.data[i]);  
170.         }  
171.     }  
172.   
173.     /** 
174.      * 交换位置 
175.      *  
176.      * @param i 
177.      *            位置i 
178.      * @param j 
179.      *            位置j 
180.      */  
181.     public void swap(int i, int j) {  
182.         int temp = data[i];  
183.         data[i] = data[j];  
184.         data[j] = temp;  
185.     }  
186.   
187.     /** 
188.      * 选择排序 
189.      */  
190.     public void selectSort() {  
191.         for (int i = 0; i < size - 1; i++) {  
192.             int k = i;  
193.             for (int j = i + 1; j < size; j++) {  
194.                 if (data[k] > data[j])  
195.                     k = j;  
196.             }  
197.             if (k != i)  
198.                 swap(k, i);  
199.         }  
200.     }  
201.   
202.     /** 
203.      * 冒泡排序 
204.      */  
205.     public void bubbleSort() {  
206.         for (int i = 0; i < size - 1; i++) {  
207.             boolean flag = false;  
208.             for (int j = 0; j < size - i - 1; j++) {  
209.                 if (data[j] > data[j + 1]) {  
210.                     flag = true;  
211.                     swap(j, j + 1);  
212.                 }  
213.             }  
214.             if (!flag)  
215.                 break;  
216.         }  
217.     }  
218.   
219.     /** 
220.      * 插入排序 
221.      */  
222.     public void interSort() {  
223.         for (int i = 0; i < size; i++) {  
224.             int temp = data[i];  
225.             int sort = i;  
226.             while (sort > 0 && temp < data[sort - 1]) {  
227.                 data[sort] = data[sort - 1];  
228.                 sort--;  
229.             }  
230.             data[sort] = temp;  
231.         }  
232.     }  
233.   
234.     public static void main(String[] args) {  
235.         LineSort line = new LineSort(1000);  
236.         line.addFirst(1);  
237.         line.addFirst(-1);  
238.         line.add(-1, 2);  
239.         line.add(1, 3);  
240.         line.addLast(100);  
241.         line.updata(3, 90);  
242.         // line.remove(-1);  
243.         // line.remove(2);  
244.         // line.remove(100);  
245.         // line.remove(90);  
246.         // line.remove(1);  
247.         // line.selectSort();  
248.         // line.bubbleSort();  
249.         line.interSort();  
250.         line.display();  
251.     }  
252. }