精华内容
下载资源
问答
  • Android中ListView字母排序,实现字母挤压效果以及右侧快速选中字母,搜索关键字功能本文中阐述如何自定义EditText实现搜索框自定义的样式以及挤压字母的思路等 自定义EditText 相关的drawable文件 在activity中动态...

    Android中ListView字母排序,实现字母挤压效果以及右侧快速选中字母,搜索关键字功能

    本文中阐述如何自定义EditText实现搜索框自定义的样式以及挤压字母的思路等

    • 自定义EditText
    • 相关的drawable文件
    • 主界面以及相关的适配器
    • 结果展示

    定义要呈现的EditText的样式

    public class ClearEditText extends EditText implements  
            OnFocusChangeListener, TextWatcher { 
    
        /**
         * 定义删除按钮的引用
         * */
        private Drawable mClearDrawable; 
    
        public ClearEditText(Context context) { 
            this(context, null); 
        } 
    
        public ClearEditText(Context context, AttributeSet attrs) {
            //这个构造方法很重要,不加这个很多属性不能再XML中定义
            this(context, attrs, android.R.attr.editTextStyle);
        } 
    
        public ClearEditText(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
            init();
        }
    
    
        private void init() {
    
            //获取EidtTextDrawableRight,加入没有设置我们就使用自己的默认图片,getCompoundDrawables返回的是四个方向的图片信息
            mClearDrawable = getCompoundDrawables()[2];
            if (mClearDrawable == null) { 
                mClearDrawable = getResources() 
                        .getDrawable(R.mipmap.emotionstore_progresscancelbtn);
            }
            //设置图片的宽高,前两个是组件左上角在容器中的坐标 后两个是组件的宽度和高度
            mClearDrawable.setBounds(0, 0, mClearDrawable.getIntrinsicWidth(), mClearDrawable.getIntrinsicHeight());
            //默认初始化情况清空当前的图片信息
            setClearIconVisible(false);
            //类似于文本框里面hint文字在初始化的时候显示或者隐藏的操作,就要用到setOnFocusChangeListener,同时监听有字符出现时就显示删除按钮
            setOnFocusChangeListener(this); 
            addTextChangedListener(this); 
        } 
    
    
        /**
         * 判断是否有删除按钮
         * 设置删除按钮的点击事件:制空
         * */
        @Override
        public boolean onTouchEvent(MotionEvent event) { 
            if (getCompoundDrawables()[2] != null) { 
                if (event.getAction() == MotionEvent.ACTION_UP) { 
                    boolean touchable = event.getX() > (getWidth() 
                            - getPaddingRight() - mClearDrawable.getIntrinsicWidth()) 
                            && (event.getX() < ((getWidth() - getPaddingRight())));
                    if (touchable) { 
                        this.setText(""); 
                    } 
                } 
            } 
    
            return super.onTouchEvent(event); 
        } 
    
        /**
         * 当焦点发生变化的情况设置删除按钮
         * */
        @Override
        public void onFocusChange(View v, boolean hasFocus) { 
            if (hasFocus) { 
                setClearIconVisible(getText().length() > 0); 
            } else { 
                setClearIconVisible(false); 
            } 
        } 
    
        /**
      * 设置删除按钮的显示或隐藏场景
      * */
        protected void setClearIconVisible(boolean visible) {
            Drawable right = visible ? mClearDrawable : null; 
            setCompoundDrawables(getCompoundDrawables()[0], 
                    getCompoundDrawables()[1], right, getCompoundDrawables()[3]); 
        } 
    
        /**
         * 判断是否有字符,如果有存在字符添加删除按钮
         * */
        @Override
        public void onTextChanged(CharSequence s, int start, int count, 
                int after) { 
            setClearIconVisible(s.length() > 0); 
        } 
    
        @Override 
        public void beforeTextChanged(CharSequence s, int start, int count, 
                int after) { 
    
        } 
    
        @Override 
        public void afterTextChanged(Editable s) { 
    
        } 
    
    
        public void setShakeAnimation(){
            this.setAnimation(shakeAnimation(5));
        }
    
    
        public static Animation shakeAnimation(int counts){
            Animation translateAnimation = new TranslateAnimation(0, 10, 0, 0);
            translateAnimation.setInterpolator(new CycleInterpolator(counts));
            translateAnimation.setDuration(1000);
            return translateAnimation;
        }
    
    
    }
    

    ClearEditText设置获取焦点时的正在输入的样式以及背景样式相关的drawable文件

    line_vertiacl文件

    <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
        android:shape="rectangle">
    
        <solid android:color="@color/black"/>
        <size  android:width="1dp"/>
    </shape>

    edit_background文件
    stroke是外边框的边框宽度以及颜色
    solid是填充的内部色彩

    <?xml version="1.0" encoding="utf-8"?>
    <shape xmlns:android="http://schemas.android.com/apk/res/android"
        android:shape="rectangle">
    
        <solid android:color="@color/white"/>
    
        <stroke android:width="1dp"
            android:color="@color/green_light"/>
    
        <corners android:radius="30dp"/>
    
        <padding
            android:bottom="6dp"
            android:top="6dp"
            android:left="12dp"
            android:right="6dp"
            />
    
    </shape>

    自定义SideBar实现右边的26个字母显示快捷选取目标

    public class SideBar extends View {
        //触摸事件
        private OnTouchingLetterChangedListener onTouchingLetterChangedListener;
        //26个字母
        public static String[] b = { "A", "B", "C", "D", "E", "F", "G", "H", "I",
                "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
                "W", "X", "Y", "Z", "#" };
        private int choose = -1;// 选中的
        private Paint paint = new Paint();
    
        private TextView mTextDialog;
    
        public void setTextView(TextView mTextDialog) {
            this.mTextDialog = mTextDialog;
        }
    
    
        public SideBar(Context context, AttributeSet attrs, int defStyle) {
            super(context, attrs, defStyle);
        }
    
        public SideBar(Context context, AttributeSet attrs) {
            super(context, attrs);
        }
    
        public SideBar(Context context) {
            super(context);
        }
    
        /**
         * 重绘界面
         */
        protected void onDraw(Canvas canvas) {
            super.onDraw(canvas);
            //获取焦点改变背景颜色
            int height = getHeight();// 获取对应高度
            int width = getWidth(); //  获取对应宽度
            int singleHeight = height / b.length;// 获取每一个字母的高度
    
            for (int i = 0; i < b.length; i++) {
                //设置每一个字母的样式
                paint.setColor(Color.rgb(33, 65, 98));
                // paint.setColor(Color.WHITE);
                paint.setTypeface(Typeface.DEFAULT_BOLD);
                paint.setAntiAlias(true);
                paint.setTextSize(30);
                //选中状态
                if (i == choose) {
                    paint.setColor(Color.parseColor("#3399ff"));
                    paint.setFakeBoldText(true);
                }
                // x坐标等于中间-字符串宽度一半
                float xPos = width / 2 - paint.measureText(b[i]) / 2;
                //高度增加递增
                float yPos = singleHeight * i + singleHeight;
                canvas.drawText(b[i], xPos, yPos, paint);
                paint.reset();// 重置画笔
            }
    
        }
    
    
        /**
         * 点击的时候的状态
         * */
        @Override
        public boolean dispatchTouchEvent(MotionEvent event) {
            final int action = event.getAction();
            final float y = event.getY();// 点击Y坐标
            final int oldChoose = choose;
            final OnTouchingLetterChangedListener listener = onTouchingLetterChangedListener;
            final int c = (int) (y / getHeight() * b.length);// 点击y坐标所占总高度的比例*b数组的长度就等于点击b中的个数.
    
            switch (action) {
            case MotionEvent.ACTION_UP:
                setBackgroundDrawable(new ColorDrawable(0x00000000));
                choose = -1;
                invalidate();
                if (mTextDialog != null) {
                    mTextDialog.setVisibility(View.INVISIBLE);
                }
                break;
    
            default:
                setBackgroundResource(R.drawable.sidebar_background);
                if (oldChoose != c) {
                    if (c >= 0 && c < b.length) {
                        if (listener != null) {
                            listener.onTouchingLetterChanged(b[c]);
                        }
                        if (mTextDialog != null) {
                            mTextDialog.setText(b[c]);
                            mTextDialog.setVisibility(View.VISIBLE);
                        }
    
                        choose = c;
                        invalidate();
                    }
                }
    
                break;
            }
            return true;
        }
    
        /**
         *向外公开的方法
         * 
         * @param onTouchingLetterChangedListener
         */
        public void setOnTouchingLetterChangedListener(
                OnTouchingLetterChangedListener onTouchingLetterChangedListener) {
            this.onTouchingLetterChangedListener = onTouchingLetterChangedListener;
        }
    
        /**
         * 接口
         * 
         * @author coder
         * 
         */
        public interface OnTouchingLetterChangedListener {
            public void onTouchingLetterChanged(String s);
        }
    
    }
    

    主界面的布局展示

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent"
        android:layout_height="fill_parent"
        android:orientation="vertical"
        android:focusable="true"
        android:focusableInTouchMode="true"
        tools:context="demo.test.com.myself.sortlistview.SortActivity">
    
    
        <demo.test.com.myself.sortlistview.ClearEditText
            android:layout_margin="6dp"
            android:textCursorDrawable="@drawable/line_vertiacl"
            android:id="@+id/filter_edit"
            android:layout_marginTop="5dip"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:background="@drawable/edit_background"
            android:drawableLeft="@mipmap/search_bar_icon_normal"
            android:hint="请输入关键字"
            android:singleLine="true"
            android:textSize="15.0dip" />
    
        <FrameLayout
            android:layout_width="fill_parent"
            android:layout_height="fill_parent" >
    
            <ListView
                android:id="@+id/country_lvcountry"
                android:layout_width="fill_parent"
                android:layout_height="fill_parent"
                android:layout_gravity="center"
                android:divider="@null" />
    
            <!--设置就是设置顶部的字母排序-->
            <LinearLayout
                android:id="@+id/title_layout"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:layout_alignParentTop="true"
                android:background="#E0E0E0" >
    
                <TextView
                    android:id="@+id/title"
                    android:layout_width="wrap_content"
                    android:layout_height="wrap_content"
                    android:layout_gravity="center_horizontal"
                    android:textColor="#454545"
                    android:paddingLeft="5dip"
                    android:paddingTop="5dip"
                    android:paddingBottom="5dip"
                    android:text="A"/>
            </LinearLayout>
    
            <TextView
                android:id="@+id/dialog"
                android:layout_width="80.0dip"
                android:layout_height="80.0dip"
                android:layout_gravity="center"
                android:background="@drawable/toast_bg"
                android:gravity="center"
                android:textColor="#ffffffff"
                android:textSize="30.0dip"
                android:visibility="invisible" />
    
            <demo.test.com.myself.sortlistview.SideBar
                android:id="@+id/sidrbar"
                android:layout_width="30.0dip"
                android:layout_height="fill_parent"
                android:layout_gravity="right|center" />
        </FrameLayout>
    
    
    </LinearLayout>
    

    自定义的显示的数据Bean

    public class SortModel {
    
        private String name;   //显示的数据
        private String sortLetters;  //显示数据拼音的首字母
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getSortLetters() {
            return sortLetters;
        }
        public void setSortLetters(String sortLetters) {
            this.sortLetters = sortLetters;
        }
    }
    

    按字母大小排序比较器实现

    public class PinyinComparator implements Comparator<SortModel> {
    
        public int compare(SortModel o1, SortModel o2) {
            if (o1.getSortLetters().equals("@")
                    || o2.getSortLetters().equals("#")) {
                return -1;
            } else if (o1.getSortLetters().equals("#")
                    || o2.getSortLetters().equals("@")) {
                return 1;
            } else {
                return o1.getSortLetters().compareTo(o2.getSortLetters());
            }
        }
    }
    

    最重要的一步是要中文转拼音的操作,需要在网络中下载pinyin4j-2.5.0.jar或更高版本作为依赖添加到程序中,添加后实现转拼音方法

    public static String getPingYin(String inputString) {
            HanyuPinyinOutputFormat format = new HanyuPinyinOutputFormat();
            format.setCaseType(HanyuPinyinCaseType.LOWERCASE);
            format.setToneType(HanyuPinyinToneType.WITHOUT_TONE);
            format.setVCharType(HanyuPinyinVCharType.WITH_V);
            char[] input = inputString.trim().toCharArray();
            String output = "";
            try {
                for (char curchar : input) {
                    if (java.lang.Character.toString(curchar).matches("[\u4e00-\u9fa5]+")) {
                        String[] temp = PinyinHelper.toHanyuPinyinStringArray(curchar, format);
                        output += temp[0];
                    } else
                        output += java.lang.Character.toString(curchar);
                }
            } catch (BadHanyuPinyinOutputFormatCombination e) {
                e.printStackTrace();
            }
            return output;
        }
    

    主界面数据展示

    public class SortActivity extends Activity {
        private ListView sortListView;
        private SideBar sideBar;
        private TextView dialog;
        private SortAdapter adapter;
        private ClearEditText mClearEditText;
    
        /**
         * 上次第一个可见元素,用于滚动时记录标识。
         */
        private int lastFirstVisibleItem = -1;
        private List<SortModel> SourceDateList;
    
        /**
         * 根据拼音来排列ListView里面的数据类
         */
        private PinyinComparator pinyinComparator;
    
        /**
         * 分组的布局
         */
        private LinearLayout titleLayout;
    
        /**
         * 分组上显示的字母
         */
        private TextView title;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_sort);
            initViews();
        }
    
        private void initViews() {
    
            titleLayout = (LinearLayout) findViewById(R.id.title_layout);
            title = (TextView) findViewById(R.id.title);
    
            pinyinComparator = new PinyinComparator();
    
            sideBar = (SideBar) findViewById(R.id.sidrbar);
            dialog = (TextView) findViewById(R.id.dialog);
            sideBar.setTextView(dialog);//设置相应的字体背景样式
    
            //设置右侧触摸监听
            sideBar.setOnTouchingLetterChangedListener(new SideBar.OnTouchingLetterChangedListener() {
    
                @Override
                public void onTouchingLetterChanged(String s) {
                    //该字母首次出现的位置
                    int position = adapter.getPositionForSection(s.charAt(0));
                    if (position != -1) {
                        sortListView.setSelection(position);
                    }
    
                }
            });
    
            sortListView = (ListView) findViewById(R.id.country_lvcountry);
            sortListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
    
                @Override
                public void onItemClick(AdapterView<?> parent, View view,
                                        int position, long id) {
                    //这里要利用adapter.getItem(position)来获取当前position所对应的对象
                        Toast.makeText(getApplication(), ((SortModel) adapter.getItem(position)).getName()+"="+position, Toast.LENGTH_SHORT).show();
                }
            });
    
    
            SourceDateList = getData(getResources().getStringArray(R.array.date));
    
            // 根据a-z进行排序源数据
            Collections.sort(SourceDateList, pinyinComparator);
            adapter = new SortAdapter(this, SourceDateList, this);
            sortListView.setAdapter(adapter);
    
            sortListView.setOnScrollListener(new AbsListView.OnScrollListener() {
                @Override
                public void onScrollStateChanged(AbsListView view, int scrollState) {
                }
    
                @Override
                public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
                                     int totalItemCount) {
    
    //                LogUtils.i(+visibleItemCount+"=当前对呀的Item是="+firstVisibleItem);
    
                    //字母连续断层使不能置顶,例如  D (空) F使D到F阶段不存在置顶
                    int section;
                    try{
                         section = adapter.getSectionForPosition(firstVisibleItem);
                    }catch (Exception e){
                        return ;
                    }
                    int nextSecPosition = adapter.getPositionForSection(section + 1);
                    //解决断层置顶
                    for (int i = 1; i < 30; i++) {
                        //26个英文字母充分循环
                        if (nextSecPosition == -1) {
                            //继续累加
                            int data = section + 1 + i;
                            nextSecPosition = adapter.getPositionForSection(data);
                        } else {
                            break;
                        }
                    }
    
    
                    if (firstVisibleItem != lastFirstVisibleItem) {
                        ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) titleLayout.getLayoutParams();
                        params.topMargin = 0;
                        titleLayout.setLayoutParams(params);
                        title.setText(String.valueOf((char) section));
    
                    }
                    if (nextSecPosition == firstVisibleItem + 1) {
                        View childView = view.getChildAt(0);
                        if (childView != null) {
                            int titleHeight = titleLayout.getHeight();
                            int bottom = childView.getBottom();
                            ViewGroup.MarginLayoutParams params = (ViewGroup.MarginLayoutParams) titleLayout
                                    .getLayoutParams();
                            if (bottom < titleHeight) {
                                float pushedDistance = bottom - titleHeight;
                                params.topMargin = (int) pushedDistance;
                                titleLayout.setLayoutParams(params);
                            } else {
                                if (params.topMargin != 0) {
                                    params.topMargin = 0;
                                    titleLayout.setLayoutParams(params);
                                }
                            }
                        }
                    }
                    lastFirstVisibleItem = firstVisibleItem;
                }
            });
    
    
            mClearEditText = (ClearEditText) findViewById(R.id.filter_edit);
    
            //根据输入框输入值的改变来过滤搜索
            mClearEditText.addTextChangedListener(new TextWatcher() {
    
                @Override
                public void onTextChanged(CharSequence s, int start, int before, int count) {
                    //当输入框里面的值为空,更新为原来的列表,否则为过滤数据列表
                    filterData(s.toString());
                }
    
                @Override
                public void beforeTextChanged(CharSequence s, int start, int count,
                                              int after) {
    
                }
    
                @Override
                public void afterTextChanged(Editable s) {
                }
            });
        }
    
    
    
    
        private List<SortModel> getData(String[] data) {
            List<SortModel> listarray = new ArrayList<SortModel>();
            for (int i = 0; i < data.length; i++) {
                String pinyin = CharacterParser.getPingYin(data[i]);
                String Fpinyin = pinyin.substring(0, 1).toUpperCase();
                SortModel person = new SortModel();
                person.setName(data[i]);
                //person.setPinYin(pinyin);
                // 正则表达式,判断首字母是否是英文字母
                if (Fpinyin.matches("[A-Z]")) {
                    person.setSortLetters(Fpinyin);
                } else {
                    person.setSortLetters("#");
                }
                listarray.add(person);
            }
            return listarray;
        }
    
        /**
         * 根据输入框中的值来过滤数据并更新ListView
         *
         * @param filterStr
         */
        private void filterData(String filterStr) {
            List<SortModel> filterDateList = new ArrayList<SortModel>();
    
            if (TextUtils.isEmpty(filterStr)) {
                filterDateList = SourceDateList;
                titleLayout.setVisibility(View.VISIBLE);
                title.setText("A");
            } else {
                titleLayout.setVisibility(View.GONE);
                filterDateList.clear();
                for (SortModel sortModel : SourceDateList) {
                    String name = sortModel.getName();
                    if (name.indexOf(filterStr.toString()) != -1 || CharacterParser.getPingYin(name).startsWith(filterStr.toString())) {
                        filterDateList.add(sortModel);
                    }
                }
            }
    
            // 根据a-z进行排序
            Collections.sort(filterDateList, pinyinComparator);
            adapter.updateListView(filterDateList);
        }
    
    }
    

    适配器adapter展示

    public class SortAdapter extends BaseAdapter implements SectionIndexer{
        private List<SortModel> list = null;
        private Context mContext;
    
        public SortAdapter(Context context, List<SortModel> list ) {
            this.mContext = context;
            this.list = list;
        }
    
    
        public void updateListView(List<SortModel> list){
            this.list = list;
            notifyDataSetChanged();
        }
    
        public int getCount() {
            return this.list.size();
        }
    
        public SortModel getItem(int position) {
            return list.get(position);
        }
    
        public long getItemId(int position) {
            return position;
        }
    
        public View getView(final int position, View view, ViewGroup arg2) {
            ViewHolder viewHolder = null;
            final SortModel mContent = list.get(position);
            if (view == null) {
                viewHolder = new ViewHolder();
                view = LayoutInflater.from(mContext).inflate(R.layout.item, null);
                viewHolder.tvTitle = (TextView) view.findViewById(R.id.title);
                viewHolder.tvLetter = (TextView) view.findViewById(R.id.catalog);
                view.setTag(viewHolder);
            } else {
                viewHolder = (ViewHolder) view.getTag();
            }
    
             获取首字母的assiiint section = getSectionForPosition(position);
            //通过首字母的assii值来判断是否显示字母
            int positionForSelection = getPositionForSection(section);
    
            viewHolder.tvLetter.setOnClickListener(null);
    
            if(position == getPositionForSection(section)){
                viewHolder.tvLetter.setVisibility(View.VISIBLE);
                viewHolder.tvLetter.setText(mContent.getSortLetters());
            }else{
                viewHolder.tvLetter.setVisibility(View.GONE);
            }
    
            viewHolder.tvTitle.setText(this.list.get(position).getName());
    
            return view;
    
        }
    
    
    
        final static class ViewHolder {
            TextView tvLetter;
            TextView tvTitle;
        }
    
    
        public int getSectionForPosition(int position) {
            return list.get(position).getSortLetters().charAt(0);
        }
    
        public int getPositionForSection(int section) {
            for (int i = 0; i < getCount(); i++) {
                String sortStr = list.get(i).getSortLetters();
                char firstChar = sortStr.toUpperCase().charAt(0);
                if (firstChar == section) {
                    return i;
                }
            }
    
            return -1;
        }
    
        @Override
        public Object[] getSections() {
            return null;
        }
    }
    

    结果展示

    这里写图片描述
    这里写图片描述
    这里写图片描述
    这里写图片描述

    源码下载(请记得给好评哦,有什么问题可以留言提问,作者会尽快给予解决,O(∩_∩)O谢谢)

    http://download.csdn.net/detail/wyh_healer/9566682

    展开全文
  • 快速排序

    2020-01-28 00:10:21
    一:快速排序 将一个数组划分为两个子数组,然后通过递归调用自身为...三:如何自动设置关键字 可以设置数组最右端的数据为关键字 四:划分数组算法图解 五:代码实现 public class QuickSort { public static void ma...

    一:快速排序

    将一个数组划分为两个子数组,然后通过递归调用自身为每个子数组又进行划分,一直划分下去,最后进行排序

    二:如何划分数组

    设置关键字,把比关键字小的作为一个数组,把比关键字大的作为另外一个数组

    三:如何自动设置关键字

    可以设置数组最右端的数据为关键字

    四:划分数组算法图解

    图1

    五:代码实现

    public class QuickSort {
        public static void main(String[] args) {
            //调用划分数组的方法
            long[] arr = {1,5,6,3,2,4,2,3,9,0,8,7,6,5};
            System.out.println("原数组"+Arrays.toString(arr)); //原数组[1, 5, 6, 3, 2, 4, 2, 3, 9, 0, 8, 7, 6, 5]
            int partition = partition(arr, 0, arr.length - 1, arr[arr.length - 1]);
            System.out.println("划分数组索引位置: "+partition); //划分数组索引位置: 7
            System.out.println("划分后"+Arrays.toString(arr)); //划分后[1, 0, 3, 3, 2, 4, 2, 5, 9, 5, 8, 7, 6, 6]
    
            //快排
            sort(arr,0,arr.length-1);
            System.out.println("快排后"+Arrays.toString(arr)); //快排后[0, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 8, 9]
    
    
        }
    
        //划分数组方法
        /*
        * 传递数组
        *   left : 左端 = 0
        *   right: 右端 = arr.length-1
        *   point: 划分数组的关键字 设置为数组最右端的数据 = arr[arr.length-1]
        */
        public static int partition(long[] arr,int left,int right,long point){
            int leftPtr = left - 1;
            int rightPtr = right;
            //循环
            while(true){
                //将比关键字小的留在左端
                while (leftPtr < rightPtr && arr[++leftPtr] < point);
                //将比关键字大的留在右端
                while(rightPtr > leftPtr && arr[--rightPtr] > point);
    
                if (leftPtr >= rightPtr){
                    break;
                }else{
                    //左右交换
                    long tmp = arr[leftPtr];
                    arr[leftPtr] = arr[rightPtr];
                    arr[rightPtr] = tmp;
                }
            }
            //交换完成后,最后还要将关键字和所指的那个再交换
            long tmp = arr[leftPtr];
            arr[leftPtr] = arr[right];
            arr[right] = tmp;
    
            //返回划分数组处的索引值
            return leftPtr;
        }
    
        //快排
        public static void sort(long[] arr,int left,int right){
    
            if (right - left <= 0){
                return;
            }else {
                //用于比较的关键字
                long point = arr[right];
                //划分数组的索引位置
                int partition = partition(arr, left, right, point);
    
                //划分完成
                //对左边的子数组进行快排
                sort(arr, left, partition - 1);
                //对右边的子数组进行快排
                sort(arr, partition + 1, right);
            }
        }
    }
    
    展开全文
  • 数据结构-快速排序

    2019-09-29 11:58:47
    如何划分:设置关键字,将比关键字小的数据放在一组,将比关键字大的放在另外一组。 如何自动设置关键字:设置数组最右端的数据为关键字。 package com.chb.chap09; public class QuickSort { //划分数组 public ...

    思想:将一个数组划分为两个子数组,然后通过递归调用自身为每一个子数组进行快速排序来实现。

    如何划分:设置关键字,将比关键字小的数据放在一组,将比关键字大的放在另外一组。

    如何自动设置关键字:设置数组最右端的数据为关键字。

    package com.chb.chap09;
    
    public class QuickSort {
    	//划分数组
    	public static int part(long[]arr,int left,int right,long point) {
    		int leftPtr=left-1;
    		int rightPtr=right;
    		while(true) {
    			//循环,将比关键字小的留在左边
    			while(leftPtr<rightPtr&&arr[++leftPtr]<point);
    			//循环,将比关键字大小的留在右边
    			while(leftPtr<rightPtr&&arr[--rightPtr]>point);
    			if(leftPtr>=rightPtr) {
    				break;
    			}else {
    				//交换
    				long temp=arr[leftPtr];
    				arr[leftPtr]=arr[rightPtr];
    				arr[rightPtr]=temp;
    			}
    		}
    		long temp=arr[leftPtr];
    		arr[leftPtr]=arr[right];
    		arr[right]=temp;
    		return leftPtr;
    	}
    	//快排
    	public static void sort(long[]arr,int left,int right) {
    		if(right-left<=0) {
    			return;
    		}else {
    			//设置关键字
    			long point=arr[right];
    			//获得切入点,并对数组进行划分
    			int p=part(arr,left,right,point);
    			//对左边的子数组进行快速排序
    			sort(arr,left,p-1);
    			//对右左边的子数组进行快速排序
    			sort(arr,p+1,right);
    		}
    		
    	}
    	public static void main(String[] args) {
    		long[]arr=new long[10];
    		for (int i = 0; i < arr.length; i++) {
    			arr[i]=(long) (Math.random()*99);
    		}
    		for (long l : arr) {
    			System.out.print(l+" ");
    		}
    		System.out.println();
    		System.out.println("++++++++++++++++++++++++++++++++++");
    		
    		sort(arr,0,arr.length-1);
    		for (long l : arr) {
    			System.out.print(l+" ");
    		}
    	}
    }
    
    

    运行结果:
    在这里插入图片描述

    展开全文
  • java实现快速排序

    2018-11-08 22:30:14
    /* * 一、快速排序的思想 * 快速排序通过讲一个数组划分成两个子数组,然后通过递归调用自身为每一个子数组进行快速排序来实现。 * 二、进行划分int partition... * 三、如何自动设置关键字。 * 设置...
    	/*
    	 * 一、快速排序的思想
    	 * 		快速排序通过讲一个数组划分成两个子数组,然后通过递归调用自身为每一个子数组进行快速排序来实现。
    	 * 二、进行划分int partition(long[] arr,int left,int right);
     	 * 		设置关键字 point,将比关键字小的数据放在一组,比关键字大的放在另外一组。
    	 * 三、如何自动设置关键字。
    	 * 		设置数组最右端为关键字。
    	 * 四、实现快速排序sort(long[] arr,int left,int right);
    	 * 		运用递归调用方法进行排序。
    	 * 打印数组display(int[] arr);
    	 */
    

    QuickSort.java

    package test;
    
    public class QuickSort {
    
    	public static int partition(long[] arr,int left,int right,long point) {
    		//创建左右指针
    		int leftPtr = left-1;
    		int rightPtr = right;
    		//创建循环
    		while(true) {
    			//将关键字左边都放置为小于point的数字
    			while(leftPtr < rightPtr && arr[++leftPtr] < point);
    			//将关键字右边都放置为大于point的数字
    			while(leftPtr < rightPtr && arr[--rightPtr] > point);
    			if(leftPtr>=rightPtr) {
    				//最后一次循环后leftPtr==rightPtr此时跳出while循环
    				break;
    			}else {
    				//此时arr[leftPtr]>point而且arr[rightPtr]<point;所以此时将两个位置进行交换
    				long temp = arr[leftPtr];
    				arr[leftPtr] = arr[rightPtr];
    				arr[rightPtr] = temp;
    			}
    		}
    		//将初始的right与(leftPtr==rightPtr)进行交换等同于point与(leftPtr==rightPtr)交换
    		long temp = arr[leftPtr];
    		arr[leftPtr] = arr[right];
    		arr[right] = temp;
    		//返回当前的point位置
    		return leftPtr;
    	}
    	//创建递归方法
    	public static void sort(long[] arr,int left,int right) {
    		if(left>=right) {
    			return;
    		}else {
    			long point=arr[right];
    			int partition = partition(arr, left, right,point);
    			//关键字左边的部分调用递归进行排序
    			sort(arr, left, partition-1);
    			//关键字右边的部分调用递归进行排序
    			sort(arr, partition+1, right);
    		}
    	}
    	//创建打印方法
    	public static void display(long[] arr) {
    		for(int i=0;i<arr.length;i++) {
    			System.out.print(arr[i]+" ");
    		}
    		System.out.println();
    	}
    }
    
    

    testSort.java

    package test;
    
    import java.util.Scanner;
    
    public class testSort {
    	public static void main(String[] args) {
    		System.out.println("请输入数组的长度:");
    		Scanner sca = new Scanner(System.in);
    		long[] arr = new long[sca.nextInt()];
    		for(int i=0;i<arr.length;i++) {
    			arr[i] = (long)(Math.random()*50);
    		}
    		QuickSort.display(arr);
    		QuickSort.sort(arr, 0, arr.length-1);
    		QuickSort.display(arr);
    	}
    }
    
    
    展开全文
  • MySQL 进阶查询常用查询按关键字排序对结果进行分组限制结果条目设置别名通配符子查询 常用查询 按关键字排序 使用SELECT语句可以将需要的数据从MySQL数据库中查询出来,如果对查询的结果进行排序,该如何去实现呢?...
  • 原文:http://coolketang.com/staticOffice/5a97f32a9f5454403c524f4b.html1. 本节课将为您演示,如何对表格进行多条件组合排序。首先点击[排序和筛选]按钮,打开排序命令菜单。 2. 选择列表中的[自定义排序]选项,...
  • 原文:http://coolketang.com/staticOffice/5a97f32aee920a788082fff3.html1. 本节课将为您演示,如何根据文字内容的笔划顺序进行自定义排序。首先点击[排序和筛选]按钮,打开排序命令菜单。 2. 选择列表中的...
  • 分治算法之快速排序

    2021-01-23 11:00:58
    快速排序的基本思想:通过一趟排序将待排记录分隔成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。 实现原理 2.1、设置两个变量 low、...
  • 比如,他们常常问我,如何设置首页热门搜索,如何加如统计等。下面将总结这些操作的小技巧.  1:ecshop如何设置"首页热门搜索关键词"  后台 -> 网店设置 -> 显示设置 -> 首页搜索的关键字 在这里,你就可以轻松设置...
  • 如何做报表测试

    2012-12-28 17:21:22
    一、关于数据的测试 1.数据的来源:来源于哪张表,哪个字段,数据库中的数据0、1代表男女,页面展示是否正确...4.数据的排序:是否按照关键字排序 5.明细和总的是否一致 二、格式的测试 1.各报表的风格是否一致 2.
  • 8第八讲希尔排序 希尔间隔排序 间隔排序完成后减少数据的间隔再进行排序一次类推 再添加一些数据 9第九讲快速排序 实现划分之后来...在上面关键字是我们自己制定的那么如何自动设置关键字呢 10第十讲二叉树的基本概念
  • 1.1 创建客户化的Mapper和Reducer 正如你所见,MapReduceIntro类中你的第一个Hadoop程序产生了排序的输出,但是,因为作业的关键字是数字的,这个排序不是你所期望的,因为它按照字符排序,而不是按照数字排序。...
  • 在某些情况下,我想用NULL包括排序记录,我使用关键字NULLS FIRST.因为Hibernate中的CriteriaQuery / CriteriaBuilder默认不支持它,所以我使用Interceptor来修改本机查询.问题是,SQL Server不支持关键字NULLS...
  • 快速排序 1. 快排思想 快排通过将一个数组划分成两个子数组,然后通过递归调用自身为每个子数组进行快排实现。...设置数组最右端的数据为关键字。 快速排序 /* * 快速排序 */ public class QuickSort { /*
  • 快速排序  一、快速排序的思想。 * 快速排序通过将一个数组划分成两个子数组,然后通过递归调用自身为 ...* 设置数组最右端的数据为关键字 四、代码实现快速排序。public class QuickSort { /* *
  • 带修改的莫队:将询问按照 左端点所在的块编号为第一关键字,右端点所在的块为第二关键字,位于第几次修改之后为第三关键字 排序。 我们将块的大小设置在 n^(2/3) ,这样一共有 n^(1/3) 个块。最后算法的总复杂度会...
  • 亚马逊流量怎么来?

    2021-01-18 16:31:23
    一、站内流量 1、自然搜索流量。通过关键字站点自然排序自然搜索量和转换率。占整个列表流量一半以上的权重比,有效的关键字可以显示较高的曝光率。 影响搜索流量的主要因素有四个。...对于如何设置热门
  • 在对表进行分类汇总之前,首先要对汇总表的关键字进行排序,对小计的字段进行排序,然后单击数据中的“小计”选项将其打开。在分类汇总窗口,我们选择了分类字段【刚刚排序的字段】,选择了汇总方式,最后选择了汇总...
  • 图解快排

    千次阅读 2019-02-21 11:04:23
    下面简单演示下如何用快排来实现下面数组从小到大排序 int arr[] = {2 4 1 8 4 0 3 6 2 5 8}; 首先什么都别想,跟着我一步一步的实现它 建立模型 将这些数字放在一个数组里,下标从0开始。分别设置两个变量start,...
  • 如何设置条件断点 在编辑状态下发现成员变量或函数不能显示提示时如何打开提示功能 如何将一个通过ClassWizard生成的类删除 如何将在workspace中消失的类找出来 如何清除所有的断点 如何在ClassWizard中选择未列出的...
  • 点击蓝字关注我哦关键字没有排名就意味着什么都没有,如何做好企业网站关键字排名是困扰大多数SEO从业者的难题。搜索是一套程序,会根据程序的设置来判断一个网站的排序结果,从这个角度来说,任何网站的优点都是...
  • 关键字没有排名就意味着什么都没有,如何做好企业网站关键字排名是困扰大多数SEO从业者的难题。搜索是一套程序,会根据程序的设置来判断一个网站的排序结果,从这个角度来说,任何网站的优点都是相同的,因为网站的...
  • SQL必知必会笔记

    2010-09-13 15:08:00
    依赖于数据库如何设置。 5.order by子句对检索出的数据进行排序。这个子句必须是select语句中的最后一条子句。 6.SQL过滤与应用过滤:在客户机上过滤数据损失性能,带宽。 7.where条件:单引号用来限定字符串。如果...
  • C#编程经验技巧宝典

    热门讨论 2008-06-01 08:59:33
    4 <br>0008 为程序设置版本和帮助信息 4 <br>0009 设置Windows应用程序启动窗体 5 <br>0010 设置Web应用程序起始页 5 <br>0011 如何设置程序的出错窗口 5 <br>0012 如何进行程序调试 6 ...
  • MySQL调优(三)性能分析

    2020-06-05 20:41:13
    MySQL常见瓶颈 CPU: SQL中对大量数据进行比较、关联、排序、分组 IO: 1.实例内存满足不了缓存数据或排序等需要,导致产生大量物理...使用explain关键字可以模拟优化器执行SQL查询语句,从而指导MySQL是如何处理你的S
  • 如何设置自动排序 重复数据得到唯一的排位序列 按字符数量排序 排序字母与数字的混合内容 随机排序 排序的问题 怎样才能让数列自动加数 一个排序问题 数字的自动排序,插入后不变? 根据规律的重复的姓名列产生自动...
  • EXCEL函数公式集

    热门讨论 2010-03-16 03:26:38
    如何设置自动排序 重复数据得到唯一的排位序列 按字符数量排序 排序字母与数字的混合内容 随机排序 排序的问题 怎样才能让数列自动加数 一个排序问题 数字的自动排序,插入后不变? 根据规律的重复的姓名列产生自动...
  • 8.增加热门关键字,搜索关键字功能. 9.增加网站公告功能 10.修正cache文件夹位置 11.修正分类发布文章功能 12.增加搜索开关,设置搜索最大文章数为100. 13.去掉文章评论,网站留言功能,待2.0文章模块稳定后,开发...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 144
精华内容 57
关键字:

如何设置关键字排序