当前位置： &>&&>&&>& > 试题信息
江苏省泰州市姜堰区学年七年级语文下学期期中试题
试题名称：江苏省泰州市姜堰区学年七年级语文下学期期中试题
创 作 者：未知
试题添加：admin
更新时间： 5:46:26
试题大小：31 K
下载次数：本日：
试题等级：★★★
授权方式：免费版
运行平台：Win9x/NT/2000/XP/2003
◆试题简介：
江苏省泰州市姜堰区学年七年级语文下学期期中（考试时间：150分钟
满分：150分）
请注意：所有的答案均填写在答题卡上，答案写在试卷上无效。一、积累与运用（共30分）1．根据拼音在田字格内用正楷依次写出相应的汉字。（4分） 　　凤城河畔，碧波荡漾，戏韵yōu 然；李中公园水杉参天，万鸟翔集，倒影bān lán ；靖江岳庙雕像如生，fēn围肃穆，气势恢宏。正是旅游好时节，凤城泰州欢迎您。
2．下列句子标点符号使用正确的一项是 （2分）
　A．仰之弥高，越高，攀得越起劲，钻之弥坚，越坚，钻得越锲而不舍。　B．我的朋友啊，他说：我--我--　C．《黄河颂》选自组诗《黄河大合唱》（解放军文艺出版社2000年版）。　D．叙利亚的孩子在废墟中唱着：在战火和摧毁中，我们的伤口很深。3．下列句子成语使用错误的一项是 （2分）
　A．这些诗歌，读起来悲愤激越，慷慨淋漓，充满乐观向上的力量。　B．叶老既是躬行君子，又能诲人不倦。　C．美英法空袭叙利亚的行为令其他国家义愤填膺。　D．他嘴上虽然没有说不对，心里却不以为意。4．根据提示补写名句或填写诗文原句。（8分，①-⑥每题1分，第⑦题2分）　①
，鲜克有终。
　②见善则迁，
。　③桃李不言，
，关山度若飞。　⑤
，散入春风满洛城。　⑥杨花榆荚无才思，
。　⑦岑参在《逢入京使》一诗中用一声传语表达思亲之情的诗句是：
。5．名著阅读。（6分）【补全人物档案】（1） 根据小说《骆驼祥子》填写下面表格，完善主人公祥子的社会关系档案。（4分）祥子社会关系身份妻子恋人雇主仇人称呼虎妞②曹先生④性格①勤俭善良③恃强凌弱【辨析典型情节】（2）下列有关名著典型情节说法错误的一项是（2分）
A．《骆驼祥子》中骆驼的出现重新点燃了祥子买车的愿望，然而这个愿望最终还是成为了泡影。
B．《红岩》中甫成高是出卖江姐的叛徒，他引诱江姐被捕时，其叛徒本性完全暴露了。
C．《创业史》中郭世富进城买稻种，一心为公，觉得吃苦就是享乐。
D．《白洋淀纪事》中水生夫妻话别时，水生最后的嘱咐是：不要叫汉奸捉活的，捉住了就要和他们拼命。6．语文实践活动。（8分）　　初一语文组在4月份开展诗词里育家国情综合性学习活动，请你也来参与吧。 【仿一仿，情更浓】（1）古往今来，诗人们以诗词形式来抒发自己的爱国情怀，代表人物有屈原、陆游、辛弃疾等。请根据示例仿写两个句子（要求：结合所选诗人的品德以及作品进行仿写）。（4分）　　 示例：宋代抗金名将岳飞，精忠报国，写下了壮怀激烈的《满江红》。 我的倾情仿写：①
【创一创，意更远】 （2）年级组打算以我心中的偶像诗人为主题开展一次演讲比赛，邀请你做主持人，请撰写一段开场白。（2分）　我的智慧表达：
【改一改，爱更绵】（3）下面是语文组发布的一则关于爱国诗歌朗诵会的通知，两处画线句都有语病，请指出来。（2分）关于举办爱国诗歌朗诵会的通知初一年级各班级：　　为弘扬爱国主义精神，①提高广大学生诗歌朗诵的意识，语文组定于本周五下午三点在学校报告厅举行爱国诗歌朗诵会。②题材不限，凡讴歌祖国、歌颂英雄等健康向上的作品，均可作为朗诵。每班一名选手参赛，各班利用班会课认真选拔。请各班参赛选手于周三下午两点到初一语文办公室抽签。　　
初一语文教研组
日我的准确修改：第一处：
二、阅读理解(共60分)(一) 阅读姚范的《山行》一诗，回答第7题。（6分）百道飞泉喷雨珠，春风窈窕绿蘼芜①。山田水满秧针出，一路斜阳听鹧鸪。【注】蘼芜（míwú）：香草名。 7．（1）下列诗句与本诗抒发情感相似的一项是
（2分）　A．草树知春不久归，百般红紫斗芳菲。
B．此夜曲中闻折柳，何人不起故园情。　C．故园东望路漫漫，双袖龙钟泪不干。
D．明月松间照，清泉石上流。（2）赏析第二句春风窈窕绿蘼芜的表达效果。
（3）细读全诗，说说诗人所表达的情感。 （2分）
(二) 阅读下面文言语段，完成8～11题。(14分)　　郑燮，号板桥，清乾隆元年进士，以画竹、兰为长。曾任范县令，爱民如子。室无贿赂，案无留牍①。公之余辄与文士畅饮咏诗，至有忘其为长吏②者。迁潍县，值岁荒，人相食。燮开仓赈济，或阻之，燮曰：此何时，若辗转申报，民岂得活乎？上有谴，我任之。即发谷与民，活万余人。去任之日，父老沿途送之。【注释】①无留牍(dú )：没有遗留下的公文。牍：公文。②长吏：地方最高的官员。8．根据要求，完成下列两小题。（6分）（1）解释下列加点词的意思。（4分）　①或阻之
②民岂得活 (
)　③即发谷与民(
④活万余人 (
)（2）下列各句与去任之日中的之的用法相同的一项是（2分）
　A．又有忧彼之所忧者《杞人忧天》 B．禽兽之变诈几何哉《狼》
　C．或阻之
D．康肃笑而遣之《卖油翁》9．用/标出下面句子的朗读节奏。（2分）
　　父 老 沿 途 送 之
（在主谓间停顿）　　曾 任 范 县 令
（在动宾间停顿）10．用现代汉语翻译下列句子。（4分）（1）上有谴，我任之。
（2）卿今者才略，非复吴下阿蒙！（《孙权劝学》）
11．阅读文章，说说郑板桥身上有哪些优秀品质。（2分）
（三）阅读老舍《骆驼祥子》选段，完成12-13题。（10分）　　选段（一）　　又一个闪，正在头上，白亮亮的雨点紧跟着落下来，极硬的砸起许多尘土，土里微带着雨气。大雨点砸在祥子的背上几个，他哆嗦了两下。雨点停了，黑云铺匀了满天。又一阵风，比以前的更厉害，柳枝横着飞，尘土往四下里走，雨道往下落；风，土，雨，混在一处，联成一片，横着竖着都灰茫茫冷飕飕，一切的东西都被裹在里面，辨不清哪是树，哪是地，哪是云，四面八方全乱，全响，全迷糊。风过去了，只剩下直的雨道，扯天扯地的垂落，看不清一条条的，只是那么一片，一阵，地上射起了无数的箭头，房屋上落下万千条瀑布。几分钟，天地已分不开，空中的河往下落，地上的河横流，成了一个灰暗昏黄，有时又白亮亮的，一个水世界。　　选段（二）　　高妈给他拿出两块钱来：太太给你的，嘱咐你快吃点药！　　是了！谢谢太太！祥子接过钱来，心里盘算着上哪儿开发了它。高妈刚一转脸，他奔了天桥，足玩了一天。　　慢慢的把宅门都串净，他又串了个第二回，这次可就已经不很灵验了。他看出来，这条路子不能靠长，得另想主意，得想比拉车容易挣钱的主意。在先前，他唯一的指望便是拉车；现在，他讨厌拉车。自然他一时不能完全和车断绝关系，可是只要有法子能暂时对付三餐，他便不肯去摸车把。他的身子懒，而耳朵很尖，有个消息，他就跑到前面去。什么公民团咧，什么请愿团咧，凡是有人出钱的事，他全干。三毛也好，两毛也好，他乐意去打一天旗子，随着人群乱走。他觉得这无论怎样也比拉车强，挣钱不多，可是不用卖力气呢。12．联系具体语境，赏析下面句子。（6分）（1）从修辞角度赏析选段（一）中的画线句子。（4分）
（2）分析选段（二）中两处加点字串的作用。（2分）
13．选段（一）（二）突出了祥子性格的前后变化。试分析祥子的前后变化及变化原因。（4分）
◆其他下载： [] [] [ ]
◆关键词查询：[查找更多关于的教学资源]
◆相关试题下载：
〖专题栏目〗& &java新手求助T T~ 编写程序（java），输出字符串“This is test.”从第2个索引到第7个索引的子串。_百度知道
java新手求助T T~ 编写程序（java），输出字符串“This is test.”从第2个索引到第7个索引的子串。
我有更好的答案
public class Test{ public static void main(String[] args) {
String str=&This is test.&;
System.out.println(str.substring(2,7)); } }
采纳率：10%
来自团队：
public class Test{ public static void main(String[] args) {
String str=&This is test.&;if(str.length&=7{
System.out.println(str.substring(2,7));}else{System.out.println(str.substring(2,str.length);} } }
substring(int beginIndex, int endIndex)
返回一个新字符串，它是此字符串的一个子字符串。
你是要 用substring
还是 自己用循环写啊
多看看一些入门教程，慢慢来。。
其他2条回答
为您推荐：
其他类似问题
字符串的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。程序员面试闯关（一）：字符串匹配+排序+查找 - 简书
程序员面试闯关（一）：字符串匹配+排序+查找
首先总结以下Java和C、C++中的一般控制台输入方式，方便以后的编程题：
java键盘输入
import java.util.S
//…………
Scanner scan = new Scanner(System.in);
String s = scan.nextLine();
int a = scan.nextInt();
int b = scan.nextInt();
String s2 = scan.next();
//…………
while(scan.hasNext()){
// 这里，循环不会随着任何输入而停止，除非输入终止操作“ctrl+Z” 或“ctrl+C”等。
java读文件（会自动结束读取）
import java.util.S
//…………
FileInputStream fis = new FileInputStream(new File("/home/androidjp/file.txt"));//Ubuntu下的文件路径
scan = new Scanner(fis, "utf-8");
while(scan.hasNext()){
///读取里面的信息
//…………
} catch (FileNotFoundException e) {
e.printStackTrace();
C 输入输出（数字和字符串、文件读取）
#include &stdio.h&
#include &stdlib.h&
int main(){
freopen("D:\\file.txt", "r", stdin);//打开文件，自动填充下面要输入的数据。
//..........
scanf("%d", &a);///输入一个整数
scanf("%c", &ch); //输入一个char字符
scanf("%s" , s);///输入一串字符（遇到空格或者换行自动认为输入完毕）
ch = getchar();//输入一个char字符
getchar();//一般用于接收上一行输入完字符串后输入的换行
gets(s); //输入一串字符（遇到换号才认为输入完毕）
//.........
printf("%d\n%s" , a, s);///输入+换行
C++输入输出（数字和字符串）
#include &iostream&
int main(){
//封装起来的字符串
char chs[5];//字符串（原始模样）
cin && s &&///输入字符串 + 空格/换行 + 输入数字（如果输入了‘abc def 123’，那么，s=‘abc’ ，a=‘0’）
//........
cout && s && " , " && a && " , " && chs &&
///串连起来输出（endl为换行）
cout && s[2];
//输出 字符串 s 的第三个字符。
一、字符串匹配
题型：大字符串（长度为n）中，是否存在子字符串（长度为m，m&=n）？
KMP算法思路：利用一个O(m)的预处理，将匹配的复杂度降为O(n+m)。利用int[] 类型的next数组，去预处理这个需要匹配的子串，将子串中每一个元素b[i] 前面的字符串段的前缀和后缀的最大共有字符个数记录为next[i]，这样，通过这个辅助数组next[i] ，b[j] 与 a[i]如果不匹配，那么，就可以让 j 回溯到next[j] ，从而让 与后缀完全匹配的前缀的后一个元素b[新的j] 去与a[i] 进行匹配。
Java实现：
import java.util.S
KMP字符串匹配算法：实际上是根据不匹配字符位置之前的字串的前缀和后缀相同的最大长度，根据这个长度，去一次移动子串多位，以达到O(n+m)的复杂度
获取子串上每一个位置之前的字符串的前后缀的最大相同长度。
让大串和子串比较，每次比较途中遇到不匹配的字符，就根据“j = next[j]”去让大串中的第i个字符与子串中第j个字符比较，模拟子串后移的过程
Created by androidjp on 16-8-4.
public class KMP {
获取next数组
public static int[] getNext(String b){
int j = 0;
int len = b.length();
int[] next = new int[len+1];
next[0] = next[1] = 0;
for(int i=1;i&b.length();i++){
while(j&0 && b.charAt(i)!=b.charAt(j)) j = next[j];
if(b.charAt(i) == b.charAt(j)) j++;
next[i+1] =
public static void match(String a, String b, int[] next){
int j = 0;
for(int i=0;i&a.length();i++){
while(j&0 && a.charAt(i)!=b.charAt(j)) j = next[j];
if (a.charAt(i) == b.charAt(j)) j++;
if (j == b.length()){
System.out.println(i+1-j);///输出完全匹配时i的初始位置（因为这时i=a.length-1, 而j=b.length ，所以i要加一）
System.out.println("-1");
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
String a,b;
while(scan.hasNext()){
a = scan.next();
b = scan.next();
match(a, b, getNext(b));
* C 实现：
///这里，可以利用数组的第一个元素来记录字符串的长度，以下就是另一种写法，但思路一致。
include "stdio.h"
include "stdlib.h"
define TRUE
define FALSE
define ERROR
define INFEASLBLE
define OVERFLOW
define MAXSTRLEN
//用户可在255以内定义最大串长
typedef unsigned char SString[MAXSTRLEN+1]; //0号单元存放串的长度
void get_next(SString T,int next[])
int i=1,j=0;
next[1]=0;
while(i&=T[0])
if(j==0||T[i]==T[j])
if(T[i]==T[j]) next[i]=next[j];
else next[i]=j;
else j=next[j];
int Index_KMP(SString S,SString T)
int next[255];
get_next(T,next);
while(i&=S[0]&&j&=T[0])
if(j==0||S[i]==T[j])
else j=next[j];
if(j&T[0]) return i-T[0];
else return 0;
int main()
SString T,S;
int i,j,n;
// freopen("case.txt","r",stdin);
scanf("%d",&n);
// 指定n对需进行模式匹配的字符串
ch=getchar();
for(j=1; j&=n; j++)
ch=getchar();
for( i=1; i&=MAXSTRLEN&&(ch!='\n'); i++)
// 录入主串
ch=getchar();
// S[0]用于存储主串中字符个数
ch=getchar();
for( i=1; i&=MAXSTRLEN&&(ch!='\n'); i++)
// 录入模式串
ch=getchar();
// T[0]用于存储模式串中字符个数
pos=Index_KMP(S,T);
printf("%d\n",pos);
## 二、排序
#### 快排（QuickSort）
* 思路：改进版的冒泡排序，采用（取基准值-交换排序-递归）的一个过程。
* 写法：一般是三个函数：①quickSort(int[] arr) 【入口函数】 ②quickSort(int[] arr, int first, int last) 【递归调用函数】 ③ partition(int[] arr, int first, int last) 【获取随机基点（可以随机，可以取中间）并实际交换排序过程函数】
* 时间复杂度：
* 平均：O(nlogn)
* 最好：O(n)
* 最坏：O(n平方)【数组本身有序 + 每次取最后一个数字作为基准】
* 空间复杂度：
* 平均：O(logn)
* 最好：O(logn)【n个元素，则递归树的高度为logn】
* 最坏：O(n) 【此时需要n-1次递归调用】
* 稳定性：不稳定
* Java写法：
* 快速排序
public static void
quickSort(int[] data) {
quickSort(data, 0, data.length-1);
private static void quickSort(int[] data, int first,
int last) {
if(first & last){//只要有两个以上的元素
int privotIndex = partition(data, first, last);
quickSort(data, first,privotIndex-1);
quickSort(data, privotIndex+1, last);
private static int partition(int[] data, int first, int last) {
int pivot = data[first];///取第一个元素为基准
int pivot = randomInRange(first,last);
///或者随机取一个元素
然后与第一个元素交换
int t = data[pivot];
data[pivot] = data[first];
data[first] =
int low = first +1;
int high =
while(low & high){
* 1. 找左侧比基准大的值
while(low &= high && data[low]&= pivot){
* 2. 找右侧比基准小的值
while (low &= high && data[high]&pivot){
if (low & high){
int temp = data[low];
data[low] = data[high];
data[high] =
* 所有交换完毕后，需要将这个基准点插入到一个适当的位置
while(high & first && data[high]&=pivot){
///找到了交换点
if (pivot & data[high]){
data[first] = data[high];
data[high] =
}else{///不用交换，表示这一次交换后，数组基本就是有序了
* 随机取值
private static int randomInRange(int start, int end) {
return new Random().nextInt(end-start+1)+
#### 归并排序（MergeSort）
* 思路：利用辅助数组，进行一个“分治 - 合并” 的过程。与快排不同，快排是‘一边分一边执行交换排序’，而归并排序是‘拆分，进行比较排序，排了再合并’。每次拆分，用到两个部分的辅助数组，每次合并，用到一个长的辅助数组，所以多用了O(2N)的空间。
* 写法：一般分两个函数：①mergeSort(int[] arr)【递归分治主函数】②merge(int[] a,int[] b) 【合并函数】
* 时间复杂度：O(nlogn)
* 空间复杂度：O(n)
* 稳定性：稳定
* Java写法：
* 归并排序
public static void mergeSort(int[] data) {
///递归条件
if (data.length &1){
* 1. 拆分两半
int[] firstHalf = new int[data.length/2];
System.arraycopy(data,0,firstHalf,0,firstHalf.length);
mergeSort(firstHalf);
int[] secondHalf = new int[data.length - data.length/2];
System.arraycopy(data,data.length/2,secondHalf,0,secondHalf.length);
mergeSort(secondHalf);
* 2. 合并两个部分
int[] temp = merge(firstHalf, secondHalf);
* 重要：copy回原来的数组
System.arraycopy(temp, 0 , data, 0 , temp.length);
private static int[] merge(int[] a, int[] b) {
int[] temp = new int[a.length+ b.length];
int i = 0;
int j = 0;
int k = 0;
while(i&a.length && j&b.length){
if (a[i] &b[j]){
temp[k++]= a[i++];
temp[k++] = b[j++];
while(i & a.length)
temp[k++] = a[i++];
while(j & b.length)
temp[k++] = b[j++];
#### 冒泡排序（BubbleSort）
* 思路：从后往前移动小元素，把小的元素移到大的元素前面，一次遍历至少可以移动一个小元素上去顶端。相邻元素之间的比较和交换，第一遍：从len-1 到0， 第二遍：从len-1 到1 ，……
* 平均/最差时间复杂度：O(n平方)
* 最好时间复杂度：O(n)【从arr[len-1] 到arr[0] 的过程没有一次交换】
* 稳定性：稳定
* Java写法：
* 冒泡排序
* 相邻元素比较和交换的过程
* 1. 从len-1 到 0
* 2. 从len-1 到 1
* 3. 从len-1 到 2
* …………
private static void bubbleSort(int[] data) {
if (data== null|| data.length==0){
new RuntimeException("参数无效");
for (int i=0;i&data.length-1;i++){
boolean isSwap =
for(int j=data.length-1;j&i;j--){
if (data[j] & data[j-1]){
int temp = data[j-1];
data[j-1] =data[j];
///设置为“需要交换”
if (!isSwap)
#### 直接选择排序（SelectSort）
* 思路：每次从前往后查找，选择乱序中最小的元素，放到上面来。
* 时间复杂度：O(n平方)【只适用于从大量元素中选择一部分排序元素，例如从1w个元素中找出前10个元素】
* 稳定性：不稳定
* Java写法：
public static void selectSort(int[] data){
if (data == null || data.length &= 0)
throw new RuntimeException("Invalid Paramemers");
////每次从前到后选择最小的元素，把它交换上来
for(int i=0;i&data.length-1;i++){
int minIndex
for(int j = i+1;j&data.j++){
if (data[j] & data[minIndex]){
minIndex =
if (minIndex != i) {
int temp = data[minIndex];
data[minIndex] =data[i];
#### 堆排序（HeapSort）
* 思路：一种树形选择排序算法。排序过程中将data[1…n]当做一颗完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和子结点之间的内在关系，在当前无序区中选择关键字最大（或最小）的元素。
* 时间复杂度：O(nlogn)
* 空间复杂度：O(1)
* 稳定性：不稳定
* 分析：**由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。**
* Java写法：
* @param data
public static void heapSort(int[] data, int len){
if(data==null || len&=0)
throw new RuntimeException("invalid parameters");
* 1. 初始化堆（从最小个的堆开始整理，慢慢整理到最大个的堆）
for(int i=len/2;i&=1;i--){//从最后一个拥有子结点的结点开始往上循环调整堆
initHeap(data, i,len);
System.out.println(data[1]);
* 2. 一个个堆顶的值的输出，并重新调整堆的过程
for(int i=i&=2;i--){
//首先，将堆顶元素与数组末尾的元素换位置，然后，数组整理堆调整长度-1
int temp = data[i];
data[i] = data[1];
System.out.println("这次换位之后，末尾的值是："+ data[i]);
initHeap(data, 1,i-1);
//构造大顶堆的过程
private static void initHeap(int[] data, int low, int high) {
int j = i*2;
int temp = data[i];
while(j&=high){
if (j&high && data[j]&data[j+1]) j++;
if (temp & data[j]){
data[i] = data[j];
data[i] =//从后往前赋值
#### 直接插入排序（InsertSort）
* 思路：将数组中第二个元素开始，每个元素都慢慢往前查找最适合插入的点，然后插入（让前面的元素一一后移一位，让出位置给其插入。
* 平均/最差时间复杂度：O(n平方)
* 最好事件复杂度：O(n)
* 空间复杂度：O(1)
* 稳定性：稳定
* Java写法：
private static int[] insertSort(int[] data, int len) {
if(data != null && len & 0) {
for(int i = 1; i & ++i) {
///从第二个元素开始
int temp = data[i];
for(j = i - 1; j &= 0 && data[j] &= --j) { ///寻找适合的插入位置
data[j + 1] = data[j];///慢慢让前面的元素后移，腾出位置
data[j + 1] = ///最后插入
///最终输出排好序的数组
throw new RuntimeException("参数无效");
#### 希尔排序（ShellSort）
* 思路：用一个间隔参数（也可以说是增量）d， 去将原来插入排序的一一后移 1 步，变成 一一后移 d 步，比如：d = 2，那么，整个数组拆分成两组：{a[0],a[2],a[4]}和{a[1],a[3],a[5]}，然后组内比较，实际上就是间隔着去移位和插入【实际上，如果数组一开始就是有序的，那么Shell和Insert两种排序所需要的比较次数和移动次数都会很少。】
* n 比较小：InsertSort的最好和最坏时间复杂度O(n)和O(n平方)差别不大
* n 比较大：InsertSort的最坏事件复杂度则效率较低，而这时，由于一个d的存在，首先就把一部分本来需要的插入移位操作给做了，所以，这时，当gap以除以2的速度减小时，这一整趟排序整体需要的比较次数和移位次数就少了，于是效率高了。
* 平均时间复杂度：O(n^1.3)
* 空间复杂度：O(1)
* 稳定性：不稳定（因为每次‘分组’之后，原来排在前面的‘1’，可能变成排到后面去了）
* Java写法：
private static int[] shellSort(int[] data, int len) {
int d = len/2;
while(d & 0){
for(int i=d; i& i++){
int temp = data[i];//取第len/2个元素（数组后半段）拿这个元素和前一组的所有元素进行比较，看到适当的位置就插入
int j = i -
while(j &=0 && temp & data[j]){///每次需要腾出位置时，不是移动一个位置，而是移动d个位置
data[j+d] = data[j];
data[j+d] =
#### 基数排序（RadixSort）
* 思路：将数组中每一个元素按：个位、十位、百位、……的顺序取一个自然数出来，然后对他们进行比较和排序。在排序过程中类似于HashMap的那种数组加链表的结构，所以需要一个辅助类Node，表示一个链表结点，只是这个数组只有0~9这几个元素。
* 平均/最好/最差时间复杂度：O(nlog(r)m)【r表示采用的基数，m表示堆数】
* 空间复杂度：O(r)
* 稳定性：稳定
* Java写法：
* 基数排序（桶排序），某些时候，效率会高一点
* 效率与：进制 、位数 、数组元素个数 、元素的最高位数
private static int[] radixSort(int[] data, int len, int jinzhi, int weishu) {
if (data == null || len &= 0 || jinzhi &= 0 || weishu & 1)
throw new RuntimeException("Invalid Parameters");
///这里就需要将这个数组中所有元素都变成一个Node类
class Node {
Node myHead = new Node();
myHead.next =
Node myTail = myH
///数组 转 链表
for (int i = 0; i & i++) {
Node item = new Node();
item.num = data[i];
item.next =
myTail.next =
///===========================================
Node[] heads = new Node[jinzhi];
Node[] tails = new Node[jinzhi];
Node tempHead =
for (int i = 0; i & i++) {
* 1. 首先，初始化大数组
for (int j = 0; j & j++) {
heads[j] =
tails[j] =
tempHead = myH
* 2. 然后，放桶
while (tempHead.next != null) {//证明有数组
tempHead = tempHead.
int k = getDigit(tempHead.num, i);
if (heads[k] == null) {///直接数组头就开始存放元素，这样就少了(进制)个Node空间
heads[k] = tempH
tails[k] = heads[k];
tails[k].next = tempH
tails[k] = tails[k].
* 3. 重新 连成链表
myHead.next =
myTail = myH
///注意，取出每一个小链表来构建大链表的过程中：
for (int j = 0; j & j++) {
if (heads[j] !=null){
if (myHead.next == null){
myHead.next = heads[j];
//注意这里，当大链表不为空的情况，记得修复好myTail.next去连接
myTail.next = heads[j];
myTail = tails[j];
myTail.next =
tempHead =
* 4. 最终，重新：链表 转 数组
myTail = myH
int k = 0;
while (myTail.next != null) {
myTail = myTail.
data[k++] = myTail.
//返回数组
public static int getDigit(int x, int d) {
int a[] = {1, 10, 100, }; // 如果实例的最大数是百位数，那就只要到100就可以了
return ((x / a[d]) % 10);
## 三、查找
#### 二分查找
* 平均/最差时间复杂度：O(logn)
* 平均查找长度ASL：log(n+1) - 1
* 空间复杂度：O(1)
* 前提要求：线性表是有序的。
* 适用情况：为保持顺序表的有序，表的插入和删除操作都需要移动大量元素，所以折半查找特别适用于一旦建立就很少改动，又经常需要进行查找的线性表。
* Java写法：
public static int BinarySearch(int[] data, int len, int key){
if (data == null || len &=0)
throw new RuntimeException("invalid parameters");
int low = 0;
int high = len -1;
while(low &= high){
int mid = (low + high)/2;
if(data[mid] == key)
else if (data[mid]& key)
low = mid+1;
high = mid-1;
return -1;
## 四、内排序方法的比较和总结
& 补充说明：
关于**基数排序**的平均时间复杂度、最差时间复杂度和空间复杂度，可以如下理解：
1. 排序分类（按时间复杂度）：
* **平方阶O(n^2)排序**，一般称为简单排序，例如直接插入排序，直接选择排序和冒泡排序
* **线性对数阶O(nlogn)排序**，如快速排序、堆排序和归并排序
* **线性阶O(n)排序**，如基数排序（假定数据的位数d和进制r为常量时）
2. 使用结论
1. 若n较小（如n&=50），可采用直接插入排序或直接选择排序。当元素规模较小时，直接插入排序较好；否则因为直接选择排序移动的元素少于直接插入排序，应选直接选择排序。
2. 若文件初始状态基本有序（指正序），则应选用直接插入、冒泡或随机的快速排序。
3. 若n较大，则应采用时间复杂度为O(nlogn)的排序方法：快速排序、堆排序或归并排序。快速排序被认为是目前基于比较的内部排序中较好的方法，当待排序的关键字随机分布时，快速排序的平均时间最短；但堆排序所需的辅助空间比快速排序少，并且不会出现快速排序可能出现的最坏情况。这两种排序都是不稳定的，若要求稳定，则可选用归并排序。
4. 若要将两个有序表合并成一个新的有序表，最好的方法是归并排序。
5. 在基于比较的排序方法中，至少是需要O(nlogn)的时间。而基数排序只需要一步就会引起r种可能的转移，即把一个元素装入r个队列之一，因此一般情况下，基数排序可能在O(n)时间内完成对n个元素的排序。但遗憾的是，基数排序只适用于像字符串和整数这类有明显结构特征的关键字，而当关键字的取值范围属于某个无穷集合（例如实数型关键字）时，无法使用基数排序，这时只有借助于“比较”的方法来排序。由此可知，若n很大，元素的关键字位数较少且可以分解时，采用基数排序较好。
参考文章：
http://www.jianshu.com/p/3471b2dfa2b4#
Android/Java 研发工程师，旨在与世界各路技术大神交流和共同学习
背景 一年多以前我在知乎上答了有关LeetCode的问题, 分享了一些自己做题目的经验。 张土汪：刷leetcode是什么样的体验？ 慢慢有一些赞和感谢, 备受鼓舞, 于是我把所做过的题目用一个script跑了一下，编辑成一篇文章。这个总结页面是这么规划的： 题目名称(答案...
第1章 第一个C程序第2章 C语言基础第3章 变量和数据类型第4章 顺序结构程序设计第5章 条件结构程序设计第6章 循环结构程序设计第7章 数组第8章 指针第9章 函数第10章 结构型、共用型、枚举型及用户自定义型数据第12章 文件第14章 预处理宏命令 第1章 第一个C程...
一、 1、请用Java写一个冒泡排序方法 【参考答案】 public static void Bubble(int a[]){ for(int i=0;i for(int j=a.length-1;j&i;j--){ if(a[j] a[j]=a[j]+a[j-1]; a[...
查找和排序都是程序设计中经常用到的算法。查找相对而言较为简单，不外乎顺序查找、二分查找、哈希表查找和二叉排序树查找。排序常见的有插入排序、冒泡排序、归并排序和快速排序。其中我们应该重点掌握二分查找、归并排序和快速排序，保证能随时正确、完整地写出它们的代码。同时对其他的查找和...
百战程序员_ Java1573题 QQ群：034603 掌握80%年薪20万掌握50%年薪10万 全程项目穿插, 从易到难，含17个项目视频和资料持续更新，请关注www.itbaizhan.com 国内最牛七星级团队马士兵、高淇等11位十年开发经验专...
风 吹散了 我的思绪 轻盈的 似乎将回忆掠起 雨 打湿了 我的衣襟 冰冷的， 似乎又带着暖意。 梦 回到了 那个故乡。 沉醉的 是过去的美丽 人 总是要 面对离别 可 却独自在 夕阳下悲涕
我就，静静地打坐 任世界热火朝天 室外蝉鸣撕裂 任暴雨倾盆 也让思念，如阵清风 飘过，陈年往事 不经少年的梦啊 在童年的秋千上 随炙日欢颜 轻撩那片荷塘月色 把蛙声悉数拾掇 再仰望繁星北斗 枕着一抹夜色 笑猜天狗藏在云朵哪端 如今不惑的我 竟囚在钢筋森林之间 悲喜着风来寒暑...
一般来说一个国家的开放程度会多少体现在民众的服装上。最典型的是中东的女人们，在保守的国度里女人不但不能露出身体的肢体部分，有的地方连脸都得遮上。于是女人们只能在脚上下大功夫，钱都花在一双双昂贵精美的鞋子上。 而欧美各国的女子则可以穿得极为清凉，上衣少到了最小的面积，短裤短到...
从6月份开始学习了易效能开始慢慢的去做，从早睡早起开始早上我把时间定在早上5点起床有一段时间一直维持可是发现白天的我一点没精神总是犯困由于工作原因中午没有时间午休明显不能适应，接下来就调整了时间晚上11睡早上6点床感觉很喜欢现在的作息规律到店就醒不用闹钟很美好哦！ 起床了晨...
由上面一章中，我们了解了什么是RunTime的数据结构，下面了解一下Runtime的消息发送。 我们知道[object doSomething]被编译器转化为: 在Objective-C中，消息直到运行时才会绑定到方法的实现上。编译器会把代码中[object doSomet...