数据结构面试题和常用算法（4）

排序算法

这种算法就是 先写好 运行一次 的代码， 之后再在外面嵌套循环

1.1 冒泡排序

package paixu;

import java.util.Arrays;

/**
 * @program: jdk8Test
 * @description: 排序算法
 * @author: liuchen
 * @create: 2020-03-26 21:32
 **/
public class Test {
    public static void main(String[] args) {
        int[] map = {1, 3, 43, 244, 9044};
        demo1(map);
        System.out.println(Arrays.toString(map));
    }

    public static void demo1(int[] map) {

        boolean flag = false; //标记位置
        for (int j = 0; j < map.length - 1; j++) {
            for (int i = 0; i < map.length - 1 - j; i++) {
                if (map[i] > map[i + 1]) {
                    map[i] = map[i] ^ map[i + 1];
                    map[i + 1] = map[i] ^ map[i + 1];
                    map[i] = map[i] ^ map[i + 1];
                    flag = true;
                }
            }
            //在交换中一次都没有发送，那就说明现在的序列数有序的。
            if (flag == false) {
                break;
            } else {
                //说明有排序，重置标记位
                flag = false;
            }

        }
    }


}

1.2 选择排序

代码

 public static void demo2(int[] map) {
        //选择排序
        for (int j = 0; j < map.length - 1; j++) {
            int min = map[j];
            int minIndex = j;
            for (int i = j; i < map.length - 1; i++) {
                if (min > map[i + 1]) {
                    min = map[i + 1];//找到最小值
                    minIndex = i + 1;
                }
            }
            //交换
            map[minIndex] = map[j];
            map[j] = min;
            System.out.println(Arrays.toString(map));
            System.out.println("=============================");
        }
    }

1.3 插入排序

写这个算法和之前的算法是一样 都是先写出运行一遍，之后在写运行多遍，找出规律

/******************************************************************************************************************

                      这是运行分部运行
*******************************************************************************************************************
*/

 public static void demo3(int[] map)
    {
        	//这是第一遍
            int currentValue=map[1]; //当前的无序列表的第一个元素
            int insertIndex = 1-1; //有序列表的第一个元素 。在第一次的时候，有序表只有一个下标为0的元素，
            while (insertIndex >=0 && currentValue<map[insertIndex]){
                map[insertIndex+1] = map[insertIndex];//数据移动。 从有序表到无序表
                insertIndex--;
            }
            //循环跳出之后，说明找到合适的位置 赋值就好
            map[insertIndex+1] = currentValue;
			

	    //第二次
		   int currentValue=map[2]; //当前的无序列表的第一个元素
            int insertIndex = 2-1; //有序列表的第一个元素 。在第二次时候执向有序表的从左往右数的最后一个
            while (insertIndex >=0 && currentValue<map[insertIndex]){
                map[insertIndex+1] = map[insertIndex];//数据移动。 从有序表到无序表
                insertIndex--;
            }
            //循环跳出之后，说明找到合适的位置 赋值就好
            map[insertIndex+1] = currentValue;            
            

    }

通过上面的代码，就有下面的代码，只是改变了一点点 用变量控制

 public static void demo3(int[] map) {
        for (int i = 1; i < map.length; i++) {//从1开始 因为刚开始的时候有序表都是第一个元素，无序表是下标为1的元素
            int currentValue = map[i]; //当前的无序列表的第一个元素
            int insertIndex = i - 1; //有序列表的第一个元素 。在第二次时候执向有序表的从左往右数的最后一个
            while (insertIndex >= 0 && currentValue < map[insertIndex]) {
                map[insertIndex + 1] = map[insertIndex];//数据移动。 从有序表到无序表
                insertIndex--;
            }
            //循环跳出之后，说明找到合适的位置 赋值就好
            map[insertIndex + 1] = currentValue;
        }

    }

1.4 希尔排序

这里要说插入排序存在的问题

//第一次
 for (int i = 5; i < map.length; i++) {
            for (int j = i-5; j >=0  ; j -= 5) {
                if(map[j] > map[j+5]){
                    map[j] = map[j] ^ map[j+5];
                    map[j+5] = map[j] ^ map[j+5];
                    map[j] = map[j] ^ map[j+5];
                }
            }
        }
        System.out.println(Arrays.toString(map));

完整
下面的方式会让排序更慢，他是交换两个值。

  public static void demo4(int[] map) {

        for (int grap = map.length / 2; grap > 0; grap /= 2) {
            for (int i = grap; i < map.length; i++) {
                for (int j = i - grap; j >= 0; j -= grap) {
                    if (map[j] > map[j + grap]) {
                        map[j] = map[j] ^ map[j + grap];
                        map[j + grap] = map[j] ^ map[j + grap];
                        map[j] = map[j] ^ map[j + grap];
                    }
                }
            }
        }
        

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


    }

改良版 牛皮的很

 public static void demo5(int[] map) {
        //定义步长
        for (int grap = map.length / 2; grap > 0; grap /= 2) {
            //用插入排序
            for (int i = grap; i < map.length; i++) {
                int j = i;
                int temp = map[j];
                if (map[j] < map[j - grap]) {
                    while (j - grap >= 0 && temp < map[j - grap]) {
                        map[j] = map[j - grap];
                        j -= grap;
                    }
                    map[j] = temp;
                }
            }

        }
        System.out.println(Arrays.toString(map));
    }

1.5 快速排序

数据结构 韩顺平老师

1.6 归并排序

数据结构 韩顺平老师

1.7基数排序

数据结构 韩顺平老师

排序算法时间复杂度比较