R语言--希尔排序，快速排序，弦截法

若已知任意函数f(x),求其在区间[a,b]上的零点可以采用弦截法，方法描述如下

请写出此方法的算法描述。

1. x=a
2. if f(x) != 0 then goto 3. else return(x)
3. if f(x)<0 then a = x else b = x
4. if |b-a|<delta then return(x) else goto 5
5. x = x- f(a)/(f(b)-f(a))*(b-a)
6. goto 2

请写出R代码实现1中的算法（截图）

eps <- 1e-10
delta <- 1e-10

s1 <- function(f,a,b){
    x <- a
    while(abs(f(x))> eps){
        if( f(x)<0){
            a <- x
        }else{
            b = x
        }
        if(abs(b-a)<delta) break
        x = x-f(a)/(f(b)-f(a))*(b-a) 
    
    }
    return(x)
}

f <- function(x){
    return(x^5-6*x^4+3*x^3-5)
}

利用2中的代码，取f(x)=x^5-6*x4+3*x^3-5在[0,7]上的一个零点（截图）

x <- s1(f,0,7)
f(x)

希尔排序的描述如下：

1. 先取定一个小于n的整数d作为第一个增量，把表的全部记录分成d组

2. 所有距离为d1的倍数的记录放在同一组中，在各组内进行直接插入排序

3. 然后取第二个增量d2<d1

4. 重复上述的分组和排序，直至增量d＝1，即所有记录放在同一组中进行直接插入排序为止。

直接插入排序算法思想如下：

记录存放在数组R[0….n-1]中，排序过程的某一中间时刻，R被划分成两个子区间R[0…i-1]和R[i….n-1]，其中：前一个子区间是已排好序的有序区；后一个子区间则是当前未排序的部分。这时，将当前无序区的第1个记录R[i]插入到有序区R[0….i-1]中适当的位置，使R[0…i]变为新的有序区
。重复这一步，直至无序区没有元素为止。

请写出：

希尔排序的算法（截图）

希尔排序算法：

1. d = [n/2]
2. i = 1
3. 找到第i组数据位置，记为ids
4. 对x[ids]用直接插入排序
5. i= i+1
6. if i>d then goto 7. else goto 3.
7. d = [d/2]
8. if d>1 then goto 2.
9. 对x用直接插入排序
10. 输出结果

直接插入排序：

1. i= 1

2. j = i+1,k=1

3. if x[j-k+1]>=x[j-k] then goto 7 else goto 4.

4. x[j-k+1] 与 x[j-k]交换位置

5. k = k+1

6. if j-k = 0 then goto 7. else goto 3.

7. i = i+1

8. if i = n goto 9. else goto 2.

9. 输出结果

与算法对应的代码（截图）

zj <- function(x){
    n <- length(x)
    if(n==1) return(x)
    for(i in 1:(n-1)){
        j <- i+1
        for(k in 1:(j-1)){
            if(x[j-k+1]<x[j-k]){
                tmp = x[j-k]
                x[j-k] = x[j-k+1]
                x[j-k+1] = tmp 
            }
        }
    }
    return(x)
}
xr <- function(x){
    n <- length(x)
    d <- floor(n/2)
    while(d>1){
        for (i in 1:d){
            id <- seq(from = i,to = n,by=d)
            x[id] <- zj(x[id])        
        }
        d = floor(d/2)
    }
    x= zj(x)
    return(x)
}

针对不同情况测试代码的有效性（截图）

快速排序的算法思想，算法描述及代码如下，请提交完整无误的代码。
quick <- f(x){

1. 选枢轴值x0

2. 通过一系列的对比交换，将枢轴值放到正确的位置。

3. 记枢轴值左右的子序列分别为L，R

4. xl = quick(L)

5. xr = quick®

6. return(c(xl,x0,xr))

}

quick_1(x)

1. x0 = x[1],loc = 1

2. low = 1, high = length(x)

3 if loc ==low then 

         if x[high] < x0 then x[high]<->x[low], 

            low = low+1,loc = high

                otherwise  high = high-1

    otherwise 

        if x[low] > x0 then x[low]<-> x[high],

            high = high -1 ,loc = low

            otherwise low = low + 1

5. if low = high then goto 6. else goto 3

6. return(list(x[1:(low-1)],x[low],x[(low+1):length(x)]))





quick_1 <- function(x){

    x0 <- x[1]

    loc <- 1

    low <- 1

    n <- length(x)

    high <- n

    while(low != high){

#         print(c(low,loc,high))

        if(loc == low){

            if(x[high] < x[loc]){

                tmp <- x[high]

                x[high] <- x[loc]

                x[loc] <- tmp

                low = low+1

                loc = high

            }else{

                high = high -1

            }

        }else{

            if(x[low] > x[loc]){

                tmp <- x[low]

                x[low] <- x[high]

                x[high] <- tmp

                high = high - 1

                loc = low

            }else{

                low = low +1

            }  

        }

    }

    return(list(x[1:(low-1)],x[low],x[(low+1):n]))

}

答：

quick_1 <- function(x){
    if(length(x)<=1) return( x)
    x0 <- x[1]
    loc <- 1
    low <- 1
    n <- length(x)
    high <- n
    while(low != high){
#         print(c(low,loc,high))
        if(loc == low){
            if(x[high] < x[loc]){
                tmp <- x[high]
                x[high] <- x[loc]
                x[loc] <- tmp
                low = low+1
                loc = high
            }else{
                high = high -1
            }
        }else{
            if(x[low] > x[loc]){
                tmp <- x[low]
                x[low] <- x[high]
                x[high] <- tmp
                high = high - 1
                loc = low
            }else{
                low = low +1
            }  
        }
    }
    xl = list()
    xr = list()
    if(low>1) xl <-x[1:(low-1)] 
    if(low<length(x)) xr <- x[(low+1):n]
    return(list(xl,x[low],xr))
}


# x<- c(5,8,2,4,3,1,7,6)
x<- c(5)
quick_1(x)