算法之排序算法-shell排序(移位法)

个人觉得移位法就是借希尔排序进行分组,插入排序进行排序

注释是上一篇的交换法.

而且这种排序的真的很快

package com.ebiz.sort;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author YHj
 * @create 2019-07-30 8:53
 * shell排序-交换法
 */
public class Shell{

    public static void main(String[] args) {

        int[] arr = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 800000);
        }

        String s = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("排序前 = " + s);

        getResult(arr);

        String l = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        System.out.println("排序后 = " + l);

        //System.out.println(Arrays.toString(arr));

        //第二次分组 5/2=2 2组,每组两个数的间隔步长为2,
        //一组5个数,外层循环,一组比较4次,一共8次
//        for (int i = 2; i < arr.length; i++) {
//            //确立要比较的步长的数
//            for (int j = i-2; j >=0 ; j-=2) {
//                if (arr[j]>arr[j+2]){
//                    int temp=arr[j+2];
//                    arr[j+2]=arr[j];
//                    arr[j]=temp;
//                }
//            }
//
//        }
//        System.out.println(Arrays.toString(arr));

        //第3次分组 2/2=1 1组,,每组两个数的间隔步长为1,
        //一组10个数,外层循环,一组比较9次,一共9次
//        for (int i = 1; i < arr.length; i++) {
//            //确立要比较的步长的数
//            for (int j = i-1; j >=0 ; j-=1) {
//                if (arr[j]>arr[j+1]){
//                    int temp=arr[j+1];
//                    arr[j+1]=arr[j];
//                    arr[j]=temp;
//                }
//            }
//
//        }
        //System.out.println(Arrays.toString(arr));

    }

    public static void getResult(int[] arr) {
//        //第一次分组 10/2=5 5组,每组两个数的间隔步长为5,
//        // 一组两个数,外层循环 一组比较1次,一共5次
//        for (int i = 5; i < arr.length; i++) {
//            //确立要比较的步长的数
//            for (int j = i-5; j >=0 ; j-=5) {
//                if (arr[j]>arr[j+5]){
//                    int temp=arr[j+5];
//                    arr[j+5]=arr[j];
//                    arr[j]=temp;
//                }
//            }
//
//        }

        //控制分的组数
//        for (int i = arr.length/2; i >=1 ; i/=2) {
//            //控制每组比较的次数
//            for (int j = i; j < arr.length; j++) {
//                //每组进行比较并进行交换
//                for (int k= j-i; k >=0 ; k-=i) {
//                    if (arr[k]>arr[k+i]){
//                        int temp=arr[k+i];
//                        arr[k+i]=arr[k];
//                        arr[k]=temp;
//                    }
//                }
//
//            }
//
//
//        }

        //shell排序-移位法,即插入排序
        //控制分组
        for (int gap = arr.length/2; gap >0 ; gap/=2) {
            //所有组进行排序
            for (int i=gap; i<arr.length;i++){
                //待排序的数
                int j=i;
                int temp=arr[j];
                //进行比较
                while (j-gap >= 0 && temp <arr[j-gap]){
                    arr[j]=arr[j-gap];
                    j-=gap;
                }
                arr[j]=temp;
            }

        }

    }

}

原文地址:https://www.cnblogs.com/jiushixihuandaqingtian/p/11313073.html

时间: 2024-08-01 17:22:18

算法之排序算法-shell排序(移位法)的相关文章

数据结构与算法——希尔排序(shell排序)

//希尔排序(shell排序)#include<iostream>using namespace std;void print(int a[], int n ,int i){ cout<<i <<":"; for(int j= 0; j<n; j++) { cout<<a[j] <<" "; } cout<<endl; } /* 直接插入排序的一般形式 * * d 缩小增量,如果是直接插入

数据结构与算法之--高级排序:shell排序和快速排序【未完待续】

高级排序比简单排序要快的多,简单排序的时间复杂度是O(N^2),希尔(shell)排序的是O(N*(logN)^2),而快速排序是O(N*logN). 说明:下面以int数组的从小到大排序为例. 希尔(shell)排序 希尔排序是基于插入排序的,首先回顾一下插入排序,假设插入是从左向右执行的,待插入元素的左边是有序的,且假如待插入元素比左边的都小,就需要挪动左边的所有元素,如下图所示: ==> 图1和图2:插入右边的temp柱需要outer标记位左边的五个柱子都向右挪动 如图3所示,相比插入排序

Java常见排序算法之Shell排序

在学习算法的过程中,我们难免会接触很多和排序相关的算法.总而言之,对于任何编程人员来说,基本的排序算法是必须要掌握的. 从今天开始,我们将要进行基本的排序算法的讲解.Are you ready?Let‘s go~~~ 1.排序算法的基本概念的讲解 时间复杂度:需要排序的的关键字的比较次数和相应的移动的次数. 空间复杂度:分析需要多少辅助的内存. 稳定性:如果记录两个关键字的A和B它们的值相等,经过排序后它们相对的位置没有发生交换,那么我们称这个排序算法是稳定的. 否则我们称这个排序算法是不稳定的

八大排序算法总结及C/C++实现

概述 排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 当n较大,则应采用时间复杂度为O(nlog2n)的排序方法:快速排序.堆排序或归并排序. 快速排序:是目前基于比较的内部排序中被认为是最好的方法,当待排序的关键字是随机分布时,快速排序的平均时间最短: 1. 插入排序-直接插入排序(Straight Insertion Sort) 基本思想: 将一个记录插入到

十种常见排序算法

1.常见算法分类 十种常见排序算法一般分为以下几种: (1)非线性时间比较类排序:交换类排序(快速排序和冒泡排序).插入类排序(简单插入排序和希尔排序).选择类排序(简单选择排序和堆排序).归并排序(二路归并排序和多路归并排序): (2)线性时间非比较类排序:计数排序.基数排序和桶排序. 总结: (1)在比较类排序中,归并排序号称最快,其次是快速排序和堆排序,两者不相伯仲,但是有一点需要注意,数据初始排序状态对堆排序不会产生太大的影响,而快速排序却恰恰相反. (2)线性时间非比较类排序一般要优于

数据结构排序算法总结

在待排序的文件中,若存在多个关键字相同的记录,经过排序后这些具有相同关键字的记录之间的相对次序保持不变,该排序方法是稳定的:若具有相同关键字的记录之间的相对次序发生改变,则称这种排序方法是不稳定的.即所有相等的数经过某种排序方法后,仍能保持它们在排序之前的相对次序,则说这种排序算法是稳定的,反之,就是不稳定的. 稳定的排序算法如下表所示: 稳定的排序 时间复杂度 空间复杂度 冒泡排序(bubble sort) 最差.平均都是O(n^2),最好是O(n) 1 插入排序(insertion sort

面试题2:自己实现七个排序算法

冒泡排序: template<typename Dtype> void bubbleSort(Dtype arr[], int len) { if (len < 2) return; bool isSorted; for (int i = 0; i < len - 1; i++) { isSorted = true; for (int j = 0; j < len - 1; j++) { if (arr[j] > arr[j + 1]) { isSorted = fal

用Java实现几种常见的排序算法

用Java语言实现的各种排序,包括插入排序.冒泡排序.选择排序.Shell排序.快速排序.归并排序.堆排序.SortUtil等. 插入排序: package org.rut.util.algorithm.support; import org.rut.util.algorithm.SortUtil; /** * @author treeroot * @since 2006-2-2 * @version 1.0 */ public class InsertSort implements SortU

几种常用排序算法(bubble、select、insert、shell、未完待续)

接下来两天重新看看几种常用的排序算法. 1.冒泡排序法 每次从 i=0开始比较相邻的元素,若arr[i]>arr[i+1],则交换它们.直到把最大的元素推向最后.回到 i=0,直至完成. 1 import java.util.Scanner; 2 class bubble 3 { 4 public static void main(String[] args) 5 { 6 int n,temp; 7 int i,j; 8 int[] arr=new int[10000]; 9 Scanner s