X

由于无法提供服务器的高昂费用,博客即将迁移到github pages...

点击右上的X可以临时关闭此框并阻止跳转^_^

现在带您过去 秒后跳转...

有关MacBook从10.9.5升级到10.11(EI capitan)后的问题及解决方法

    看到别人的MAC在用最新的EI Capitan系统之后,我终于打破了自己坚持使用旧系统的原则,本着更好的体验和更高的性能,我将自己的本子也更新到最新,既然是更新升级上来的,不免有些小问题会出现,下面就逐个来说说我遇到的问题吧。

    问题一:Apache无法正常启动?

    首先遇到这个问题时,当然是去找日志了,因为在终端输入启动命令:sudo apachectl start之后,没有任何报错和提示,只是本地浏览器访问localhost or 127.0.0.1失败。但是,这个错误日志真的不好找,最后我干脆去配置文件etc/apache2/httpd.conf中寻找。

    嗯!找到了! ErrorLog “/private/var/log/apache2/error_log” 好的,我去看看到底是什么原因。可是,“/private/var/log/apache2/” 目录根本没有任何文件!想着自己给它创建这个错误日志文件吧,创建好了之后使用命令启动apache,结果文件里面没有任何内容!

    这也不行,看来通过错误日志是行不通了,于是乎,在网上查找各种资料,终于看到有个人在网页上写到:现在尝试启动一下Apache: sudo apachectl -k start。看到这个,带着好奇我也输入了一遍,好奇心真的不会害死猫!终于出现了报错了!第一次这么开心地看见报错信息,于是乎根据提示找到错误点并屏蔽掉了这个错误的配置。
    (…继续阅读这篇文章…)

Apache 反向代理 Tomcat实战

    apache's mod_proxy for tomcat

    近期突然有个想法,既然有多出来的服务器,空着也是空着,不如拿出来用作演示项目。带着这样的心情,我开始在自己的服务器上动起了手脚。

    一、现有情况:

    1. 我的博客地址:http://www.dshui.wang/
    2. 演示用的服务器地址(Tomcat):http://xxx.xx.xx.xx:8080/ (由于暴露IP和端口带来了攻击,现在取消了)
    3. 演示所用域名:demo.dshui.wang 解析至博客所在服务器(非演示用服务器)

    二、预期效果:

    1. 访问http://demo.dshui.wang/tomcat/时,展示的页面为http://xxx.xx.xx.xx:8080/所显示的页面
    2. 更近一层,http://demo.dshui.wang/tomcat/* 译为http://xxx.xx.xx.xx:8080/*  (*代表通配符

    (…继续阅读这篇文章…)

[作业练习]带数据库的简易购物车

    在前一次作业的基础上([作业]JavaBean+Jsp简易购物车实现),加上数据库来管理商品和购买记录。
    最后结果展示:http://demo.dshui.wang/tomcat/ShopCartDemo/
    首先,建立数据表:

    #用户表
    CREATE TABLE `cart_users` (
      `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
      `username` varchar(80) NOT NULL DEFAULT '',
      `password` varchar(220) NOT NULL DEFAULT '',
      PRIMARY KEY (`id`),
      UNIQUE KEY `username` (`username`)
    ) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
     (...继续阅读这篇文章...)

[作业]JavaBean+Jsp简易购物车实现

    本次作业要求使用到JavaBean+纯Jsp,带有登陆功能的购物车系统。
    登陆功能这里就不多讲了,前面的聊天室已经做过,这边直接拷贝就能使用了。
    另外,本次作业中我加入了BootStrap来做一个小小风格美化。
    不多说,直接上代码!
    index.jsp 首页,也是登陆界面

    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    <%
        Cookie[] cookies = request.getCookies();
        String uname = "";
        String upwd = "";
        if(cookies!=null){
            for(int i=0;i
    
    
        
            
            
            
            请登录ShopCartDemo
            
        
        
            

    dologin.jsp 登陆信息处理页面

    <%-- 
        Document   : dologin
        Created on : 2015-10-9, 11:28:29
        Author     : Anthony
    --%>
    
    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    <%@page import="java.util.*"%>
    
    
        
            
            正在登录...
        
        
            <%
            String username = request.getParameter("username");
            String password = request.getParameter("password");
            String remember = (String) request.getParameter("remember");
            if(username == null)
                username="";
            if(password == null)
                password="";
            if(remember == null)
                remember = "false";
            if(username.equals("201321092028")&&password.equals("123456") || username.equals("201321092027")&&password.equals("123456"))
            {
                if(remember != null && remember.equals("true"))
                {
                    Cookie cookie1 = new Cookie("remname",username);
                    Cookie cookie2 = new Cookie("rempwd",password);
                    cookie1.setMaxAge(60*60*24*5);
                    cookie2.setMaxAge(60*60*24*5);
                    response.addCookie(cookie1);
                    response.addCookie(cookie2);
                }
                session.setAttribute("UserName",username);
                session.setAttribute("IsLogin","true");
                response.sendRedirect("goods.jsp");
            }else{
                response.sendRedirect("index.jsp");
            }
            %>
        
    
    

    goods.jsp 商品列表页面

    <%-- 
        Document   : goods
        Created on : 2015-10-15, 17:11:28
        Author     : anthony
    --%>
    
    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    
    
        
            
            
            
            商品列表
            
        
        
            
    编号商品名单价(元/斤)购买数量
    1苹果13
    2橘子8
    3西瓜2
    4火龙果15

    order.jsp 订单信息页面

    <%-- 
        Document   : order
        Created on : 2015-10-15, 18:28:05
        Author     : anthony
    --%>
    
    <%@page contentType="text/html" pageEncoding="UTF-8"%>
    
    
        
            
            
            
            订单信息
            
        
        
            
                
                
                
                
            
    编号商品名单价(元/斤)数量价格
    1苹果13
    2橘子8
    3西瓜2
    4火龙果15

    另外,还需要一个JavaBean CountPrice.java

    package Cart;
    
    /*
     * To change this license header, choose License Headers in Project Properties.
     * To change this template file, choose Tools | Templates
     * and open the template in the editor.
     */
    
    /**
     *
     * @author anthony
     */
    public class CountPrice {
        private double n_apple;
        private double n_orange;
        private double n_watermalon;
        private double n_fires;
        private double p_apple;
        private double p_orange;
        private double p_watermalon;
        private double p_fires;
        private double totalprice;
    
        /**
         * @return the n_apple
         */
        public double getN_apple() {
            return n_apple;
        }
    
        /**
         * @param n_apple the n_apple to set
         */
        public void setN_apple(double n_apple) {
            this.n_apple = n_apple;
            this.setP_apple(n_apple*13);
        }
    
        /**
         * @return the n_orange
         */
        public double getN_orange() {
            return n_orange;
        }
    
        /**
         * @param n_orange the n_orange to set
         */
        public void setN_orange(double n_orange) {
            this.n_orange = n_orange;
            this.setP_orange(n_orange*8);
        }
    
        /**
         * @return the n_watermalon
         */
        public double getN_watermalon() {
            return n_watermalon;
        }
    
        /**
         * @param n_watermalon the n_watermalon to set
         */
        public void setN_watermalon(double n_watermalon) {
            this.n_watermalon = n_watermalon;
            this.setP_watermalon(n_watermalon*2);
        }
    
        /**
         * @return the n_fires
         */
        public double getN_fires() {
            return n_fires;
        }
    
        /**
         * @param n_fires the n_fires to set
         */
        public void setN_fires(double n_fires) {
            this.n_fires = n_fires;
            this.setP_fires(n_fires*15);
        }
    
        /**
         * @return the totalprice
         */
        public double getTotalprice() {
            this.totalprice = this.getP_apple()+this.getP_fires()+this.getP_orange()+this.getP_watermalon();
            return totalprice;
        }
    
        /**
         * @return the p_apple
         */
        public double getP_apple() {
            return p_apple;
        }
    
        /**
         * @return the p_orange
         */
        public double getP_orange() {
            return p_orange;
        }
    
        /**
         * @return the p_watermalon
         */
        public double getP_watermalon() {
            return p_watermalon;
        }
    
        /**
         * @return the p_fires
         */
        public double getP_fires() {
            return p_fires;
        }
    
        /**
         * @param p_apple the p_apple to set
         */
        public void setP_apple(double p_apple) {
            this.p_apple = p_apple;
        }
    
        /**
         * @param p_orange the p_orange to set
         */
        public void setP_orange(double p_orange) {
            this.p_orange = p_orange;
        }
    
        /**
         * @param p_watermalon the p_watermalon to set
         */
        public void setP_watermalon(double p_watermalon) {
            this.p_watermalon = p_watermalon;
        }
    
        /**
         * @param p_fires the p_fires to set
         */
        public void setP_fires(double p_fires) {
            this.p_fires = p_fires;
        }
        
    }

    附上NetBean项目工程:
    链接: http://pan.baidu.com/s/1o66DrjO 密码: yksy

linux下mysql的root密码忘记解决方法

    1.首先确认服务器出于安全的状态,也就是没有人能够任意地连接MySQL数据库。
    因为在重新设置MySQL的root密码的期间,MySQL数据库完全出于没有密码保护的
    状态下,其他的用户也可以任意地登录和修改MySQL的信息。可以采用将MySQL对
    外的端口封闭,并且停止Apache以及所有的用户进程的方法实现服务器的准安全
    状态。最安全的状态是到服务器的Console上面操作,并且拔掉网线。
    2.修改MySQL的登录设置:
    # vi /etc/my.cnf
    在[mysqld]的段中加上一句:skip-grant-tables
    例如:
    [mysqld]
    datadir=/var/lib/mysql
    socket=/var/lib/mysql/mysql.sock
    skip-grant-tables
    保存并且退出vi。
    3.重新启动mysqld
    # /etc/init.d/mysqld restart
    Stopping MySQL: [ OK ]
    Starting MySQL: [ OK ]
    4.登录并修改MySQL的root密码
    # /usr/bin/mysql
    Welcome to the MySQL monitor. Commands end with ; or \g.
    Your MySQL connection id is 3 to server version: 3.23.56
    Type ‘help;’ or ‘\h’ for help. Type ‘\c’ to clear the buffer.
    mysql> USE mysql ;
    Reading table information for completion of table and column names
    You can turn off this feature to get a quicker startup with -A
    Database changed
    mysql> UPDATE user SET Password = password ( ‘new-password’ ) WHERE User = ‘root’ ;
    Query OK, 0 rows affected (0.00 sec)
    Rows matched: 2 Changed: 0 Warnings: 0
    mysql> flush privileges ;
    Query OK, 0 rows affected (0.01 sec)
    mysql> quit
    Bye
    5.将MySQL的登录设置修改回来
    # vi /etc/my.cnf
    将刚才在[mysqld]的段中加上的skip-grant-tables删除
    保存并且退出vi。
    6.重新启动mysqld
    # /etc/init.d/mysqld restart
    Stopping MySQL: [ OK ]
    Starting MySQL: [ OK ]
    文章转自:http://www.cnblogs.com/allenblogs/archive/2010/08/12/1798247.html

各种排序算法介绍

    1.直接插入排序算法(Straight Insertion Sort):
    基本思想:
    将一个记录插入到已排序好的有序表中,从而得到一个新,记录数增1的有序表。即:先将序列的第1个记录看成是一个有序的子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止。
    算法的实现:

    //
    //  main.cpp
    //  Straight Insertion Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    
    void print(int a[], int n ,int i){
        cout<
    

    运行结果:
    1:5 6 1 3 2 8 9 7
    2:1 5 6 3 2 8 9 7
    3:1 3 5 6 2 8 9 7
    4:1 2 3 5 6 8 9 7
    5:1 2 3 5 6 8 9 7
    6:1 2 3 5 6 8 9 7
    7:1 2 3 5 6 7 8 9
    8:1 2 3 5 6 7 8 9
    Program ended with exit code: 0
    时间复杂度:O(n^2).
    2.选择排序—简单选择排序(Simple Selection Sort):
    基本思想:
    在要排序的一组数中,选出最小(或者最大)的一个数与第1个位置的数交换;然后在剩下的数当中再找最小(或者最大)的与第2个位置的数交换,依次类推,直到第n-1个元素(倒数第二个数)和第n个元素(最后一个数)比较为止。

    操作方法:
    第一趟,从n 个记录中找出关键码最小的记录与第一个记录交换;
    第二趟,从第二个记录开始的n-1 个记录中再选出关键码最小的记录与第二个记录交换;
    以此类推.....
    第i 趟,则从第i 个记录开始的n-i+1 个记录中选出关键码最小的记录与第i 个记录交换,
    直到整个序列按关键码有序。

    算法的实现:

    //
    //  main.cpp
    //  Simple Selection Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    
    void print(int a[], int n ,int i){
        cout<<"第"< a[j]) k = j;
        }
        return k;
    }
    
    /**
     * 选择排序
     *
     */
    void selectSort(int a[], int n){
        int key, tmp;
        for(int i = 0; i< n; ++i) {
            key = SelectMinKey(a, n,i);           //选择最小的元素
            if(key != i){
                tmp = a[i];  a[i] = a[key]; a[key] = tmp; //最小元素与第i位置元素互换
            }
            print(a,  n , i);
        }
    }
    
    int main(int argc, const char * argv[]) {
        int a[8] = {5,6,1,3,2,8,9,7};
        cout<<"初始值:";
        for(int j= 0; j<8; j++){
            cout<
    

    运行结果:
    初始值:5 6 1 3 2 8 9 7

    第1趟 : 1 6 5 3 2 8 9 7
    第2趟 : 1 2 5 3 6 8 9 7
    第3趟 : 1 2 3 5 6 8 9 7
    第4趟 : 1 2 3 5 6 8 9 7
    第5趟 : 1 2 3 5 6 8 9 7
    第6趟 : 1 2 3 5 6 7 9 8
    第7趟 : 1 2 3 5 6 7 8 9
    第8趟 : 1 2 3 5 6 7 8 9
    第9趟 : 1 2 3 5 6 7 8 9
    Program ended with exit code: 0

     简单选择排序的改进——二元选择排序

    简单选择排序,每趟循环只能确定一个元素排序后的定位。我们可以考虑改进为每趟循环确定两个元素(当前趟最大和最小记录)的位置,从而减少排序所需的循环次数。改进后对n个数据进行排序,最多只需进行[n/2]趟循环即可。具体实现如下:

    void SelectSort(int r[],int n) {
        int i ,j , min ,max, tmp;
        for (i=1 ;i <= n/2;i++) {
            // 做不超过n/2趟选择排序
            min = i; max = i ; //分别记录最大和最小关键字记录位置
            for (j= i+1; j<= n-i; j++) {
                if (r[j] > r[max]) {
                    max = j ; continue ;
                }
                if (r[j]< r[min]) {
                    min = j ;
                }
            }
            //该交换操作还可分情况讨论以提高效率
            tmp = r[i-1]; r[i-1] = r[min]; r[min] = tmp;
            tmp = r[n-i]; r[n-i] = r[max]; r[max] = tmp;
            
        }
    }
    

    3.交换排序—冒泡排序(Bubble Sort):
    基本思想:
    在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。
    算法的实现:

    void bubbleSort(int a[], int n){
        for(int i =0 ; i< n-1; ++i) {
            for(int j = 0; j < n-i-1; ++j) {
                if(a[j] > a[j+1])
                {
                    int tmp = a[j] ; a[j] = a[j+1] ;  a[j+1] = tmp;
                }
            }
        }
    }
    

    冒泡排序算法的改进
    对冒泡排序常见的改进方法是加入一标志性变量exchange,用于标志某一趟排序过程中是否有数据交换,如果进行某一趟排序时并没有进行数据交换,则说明数据已经按要求排列好,可立即结束排序,避免不必要的比较过程。本文再提供以下两种改进算法:

    1.设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

    改进后算法如下:

    void Bubble_1 ( int r[], int n) {
        int i= n -1;  //初始时,最后位置保持不变
        while ( i> 0) {
            int pos= 0; //每趟开始时,无记录交换
            for (int j= 0; j< i; j++)
                if (r[j]> r[j+1]) {
                    pos= j; //记录交换的位置
                    int tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
                }
            i= pos; //为下一趟排序作准备
        }
    }
    

    2.传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

    改进后的算法实现为:

    void Bubble_2 ( int r[], int n){
        int low = 0;
        int high= n -1; //设置变量的初始值
        int tmp,j;
        while (low < high) {
            for (j= low; j< high; ++j) //正向冒泡,找到最大者
                if (r[j]> r[j+1]) {
                    tmp = r[j]; r[j]=r[j+1];r[j+1]=tmp;
                }
            --high;                 //修改high值, 前移一位
            for ( j=high; j>low; --j) //反向冒泡,找到最小者
                if (r[j]
    

    4.交换排序—快速排序(Quick Sort)
    基本思想:
    1)选择一个基准元素,通常选择第一个元素或者最后一个元素,
    2)通过一趟排序讲待排序的记录分割成独立的两部分,其中一部分记录的元素值均比基准元素值小。另一部分记录的 元素值比基准值大。
    3)此时基准元素在其排好序后的正确位置
    4)然后分别对这两部分记录用同样的方法继续进行排序,直到整个序列有序。
    算法的实现:

    //
    //  main.cpp
    //  Quick Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    void print(int a[], int n){
        for(int j= 0; j= privotKey) --high;  //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的交换到低端
            swap(&a[low], &a[high]);
            while(low < high  && a[low] <= privotKey ) ++low;
            swap(&a[low], &a[high]);
        }
        print(a,10);
        return low;
    }
    
    
    void quickSort(int a[], int low, int high){
        if(low < high){
            int privotLoc = partition(a,  low,  high);  //将表一分为二
            quickSort(a,  low,  privotLoc -1);          //递归对低子表递归排序
            quickSort(a,   privotLoc + 1, high);        //递归对高子表递归排序
        }
    }
    
    int main(){
        int a[10] = {3,1,5,7,2,4,9,6,10,8};
        cout<<"初始值:";
        print(a,10);
        quickSort(a,0,9);
        cout<<"结果:";
        print(a,10);
        return 0;
    }
    

    分析:
    快速排序是通常被认为在同数量级(O(nlog2n))的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时,快排序反而蜕化为冒泡排序。为改进之,通常以“三者取中法”来选取基准记录,即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

    快速排序的改进
    在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序,然后再对整个基本有序序列用插入排序算法排序。实践证明,改进后的算法时间复杂度有所降低,且当k取值为 8 左右时,改进算法的性能最佳。算法思想如下:

    //
    //  main.cpp
    //  Straight Insertion Sort
    //
    //  Created by anthony on 15-10-8.
    //  Copyright (c) 2015年 anthony. All rights reserved.
    //
    
    #include 
    using namespace std;
    void print(int a[], int n){
        for(int j= 0; j= privotKey) --high; //从high 所指位置向前搜索,至多到low+1 位置。将比基准元素小的交换到低端
            swap(&a[low], &a[high]);
            while(low < high  && a[low] <= privotKey ) ++low;
            swap(&a[low], &a[high]);
        }
        print(a,10);
        return low;
    }
    
    
    void qsort_improve(int r[ ],int low,int high, int k){
        if( high -low > k ) { //长度大于k时递归, k为指定的数
            int pivot = partition(r, low, high); // 调用的Partition算法保持不变
            qsort_improve(r, low, pivot - 1,k);
            qsort_improve(r, pivot + 1, high,k);
        }
    }
    void quickSort(int r[], int n, int k){
        qsort_improve(r,0,n,k);//先调用改进算法Qsort使之基本有序
        
        //再用插入排序对基本有序序列排序
        for(int i=1; i<=n;i ++){
            int tmp = r[i];
            int j=i-1;
            while(tmp < r[j]){
                r[j+1]=r[j]; j=j-1;
            }
            r[j+1] = tmp;
        }
        
    }
    
    
    
    int main(){
        int a[10] = {3,1,5,7,2,4,9,6,10,8};
        cout<<"初始值:";
        print(a,10);
        quickSort(a,9,4);
        cout<<"结果:";
        print(a,10);
        return 0;
    }
    

    还有更多的算法,这里就不写那么多了,熟记基本的算法应付简单的程序还是可以的,重要的是学会运用其中的思想。