数据结构之排序一（冒泡、插入、选择）

目录

1.冒泡排序

2.插入排序

3.选择排序

一、冒泡排序

      重复地走访过要排序的元素列，依次比较两个相邻的元素。如果顺序错误（如从大到小、首字母从从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。是一个稳定的排序。

      就是相邻的两个数进行比较。如果大的，就进行倒手，往上冒。

      例如：按照从小到大排序。

1. 每一次遍历把最大的遍历出来。

2. 先是2和5比较，2<5，位置不变。然后，5和1比较，5>1，位置交换。然后，5现在在原来1的位置。然后，5和3比较，5>3，位置交换。5在原来3的位置，再然后，5和5比较。5=5，位置不交换。第一轮比较完成。然后再重复上面的步骤。

package Run;

public class text {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int[] sum = new int[] { 2, 5, 1, 3, 5, 0, 10, 5, -5, -10, 90 };
        int n = 0;// 记录内循环的次数
        int w = 0;// 记录外循环得次数

        // (1)直接 循环遍历比较
        for (int i = 0; i < sum.length; i++) {// 外循环（控制趟数）
            w = i;// 记录躺数

            for (int j = 0; j < sum.length - 1; j++) {// 内循环（控制比较）

                if (sum[j] > sum[j + 1]) {

                    int temp; // 倒手原理
                    temp = sum[j + 1];
                    sum[j + 1] = sum[j];
                    sum[j] = temp;
                }

                n = j;// 记录内循环次数
            }
        }

        //(2)倒叙的比较方式。
/*        for (int i = 0; i < sum.length; i++) { 
            w = i;
            
            for (int j = sum.length - 1; j > i; j--) { // 比较后的元素不再比较了。
                
                if (sum[j - 1] > sum[j]) {
                    
                    int temp;
                    temp = sum[j];
                    sum[j] = sum[j - 1];
                    sum[j - 1] = temp;
                }
                n = j;
            }
        }*/

        // (3)高效率的比较方法
        /*for (int i = 0; i < sum.length - 1; i++) { // 是length-1趟
            w = i;// 记录躺数

            for (int j = 0; j < sum.length - 1 - i; j++) { // 比较后的元素不再比较了。

                if (sum[j] > sum[j + 1]) {

                    int temp = sum[j];
                    sum[j] = sum[j + 1];
                    sum[j + 1] = temp;
                }
                n = j;// 记录内循环次数
            }

        }*/


        // 打印冒泡排序后的数组
        for (int t = 0; t < sum.length; t++) {
            System.out.print(sum[t] + "  ");

        }

        System.out.println();
        System.out.println("外循环" + w + "次");
        System.out.println("内循环" + n + "次");

    }

}

返回顶部

二、插入排序

      插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。

      插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。

      就是默认指针从第二个元素开始，将小的元素保存起来，然后比较插入。（要求请求的排序是从小到大）

例如：
　　

1. 2<5，把2保存起来，5插到2的位置。因为原来5的位置已经是第一位了，就直接把2插到原来5的位置。指针向后移一位。
2. 1<5，把1保存起来，5插到1的位置。原来5的位置前面还有一个2，将2和1比较，1<2，因为已经是第一位了，就直接交换。
3. 其他操作也是一样。一定需要保证前面的元素都是有顺序排列好的。

int[] array = new int[] {0,6,0,-1,9,0,6};
		
		 for (int i = 1; i < array.length; i++) {
			 
	            if (array[i] < array[i - 1]) {
	            	
	                int temp = array[i];
	                int f = i;
	                for (; f >= 1 && array[f - 1] > temp; f--) {
	                    array[f] = array[f-1];

	                }
	                
	            array[f] = temp;
	            
	            }
	        }
		 
		 System.out.println(Arrays.toString(array));

返回顶部

三、选择排序

      就是认为第一个元素是最小的，然后创建一个mindex。mindex用来指向最小的元素。然后，从第二个元素开始进行比较，如果谁小mindex就指向谁，直到最后一个元素，然后，把mindex指向的元素赋值给第一个元素。重复步骤。（不稳定的排序方法）

1. 假设第一个元素就是最小元素，mindex指向第一个元素。
2. 然后2和1比较，2>1，mindex指向1，
3. 然后1和6比较，6>1，mindex指向1，
4. 一直到最后一个元素，9>1，把mindex的指向1，赋值给第一位元素。

int[] array = new int[] { 2, 1, 6, 7, 3, 9 };

		for (int i = 0; i < array.length; i++) {

			// 认为第0个元素是最小的。并把其存起来
			int mixindex = i;

			// 因为是比较是从后面与前面比较的
			// 所以从第1号元素开始遍历。来比较
			for (int j = i + 1; j < array.length; j++) {

				// 判断，如果后面的数比第0号元素还小。拿指针就指向小的那个
				// 在往后找。找到最小的那个。指针指向最小的。最后和第0号元素的下标进行交换
				if (array[mixindex] > array[j]) {

					mixindex = j;// 下标进行交换;这时。mixindex指向最小的那个值
				}
			}

			// 找到最小的元素。让其和i好元素进行换位。
			// 这样就实现了。前面的都是有序的排序了
			int temp = array[i];
			array[i] = array[mixindex];
			array[mixindex] = temp;

		}

		System.out.println(Arrays.toString(array));

返回顶部