JavaScript数据结构和算法简述——数组

var array = [ ] ;

var array = new Array ( ) ; //创建一个数组

var array = new Array ( [ size ] ) ; //创建一个数组并指定长度，注意不是上限，是长度

var array = new Array ( [ element0 [ , element1 [ , . . . [ , elementN ] ] ] ] ) ; //创建一个数组并赋值

var getArrItem = array [ 1 ] ; //获取数组的元素值

array [ 1 ] = "new value" ; //给数组元素赋予新的值

array . push ( [ item1 [ item2 [ . . . [ itemN ] ] ] ] ) ; // 将一个或多个新元素添加到数组结尾，并返回数组新长度

array . unshift ( [ item1 [ item2 [ . . . [ itemN ] ] ] ] ) ; // 将一个或多个新元素添加到数组开始，数组中的元素自动后移，返回数组新长度

array . splice ( insertPos , 0 , [ item1 [ , item2 [ , . . . [ , itemN ] ] ] ] ) ; //将一个或多个新元素插入到数组的指定位置，插入位置的元素自动后移，返回""。

array . pop ( ) ; //移除最后一个元素并返回该元素值

array . shift ( ) ; //移除最前一个元素并返回该元素值，数组中元素自动前移

array . splice ( deletePos , deleteCount ) ; //删除从指定位置deletePos开始的指定数量deleteCount的元素，数组形式返回所移除的元素

array . slice ( start , [ end ] ) ; //以数组的形式返回数组的一部分，注意不包括 end 对应的元素，如果省略 end 将复制 start 之后的所有元素

array . slice ( 0 ) ; //返回数组的拷贝数组，注意是一个新的数组，不是指向

array . concat ( ) ; //返回数组的拷贝数组，注意是一个新的数组，不是指向

array . reverse ( ) ; //反转元素（最前的排到最后、最后的排到最前），返回数组地址

array . sort ( ) ; //对数组元素排序，返回数组地址

array . join ( separator ) ; //返回字符串，这个字符串将数组的每一个元素值连接在一起，中间用 separator 隔开。

toLocaleString 、 toString 、 valueOf ：可以看作是 join 的特殊用法，不常用

var arr = [ 12 , 23 , 5 , 3 , 25 , 98 , 76 , 54 , 56 , 76 ] ;

//定义了一个包含10个数字的数组

print ( arr . length ) ; //显示数组的长度10

arr . length = 12 ; //增大数组的长度

print ( arr . length ) ; //显示数组的长度已经变为12

print ( arr [ 8 ] ) ; //显示第9个元素的值，为56

arr . length = 5 ; //将数组的长度减少到5，索引等于或超过5的元素被丢弃

print ( arr [ 8 ] ) ; //显示第9个元素已经变为"undefined"

arr . length = 10 ; //将数组长度恢复为10

print ( arr [ 8 ] ) ; //虽然长度被恢复为10，但第9个元素却无法收回，显示"undefined"

var arr = [ 12 , 23 , 5 , 3 , 25 , 98 , 76 , 54 , 56 , 76 ] ;

print ( arr . length ) ; // 10

arr [ 15 ] = 34 ;

print ( arr . length ) ; // 16

function array_max ( ) {

var i ,

max = this [ 0 ] ;

for ( i = 1 ; i < this . length ; i ++ ) {

if ( max < this [ i ] )

max = this [ i ] ;

}

return max ;

}

Array . prototype . max = array_max ;

var x = new Array ( 1 , 2 , 3 , 4 , 5 , 6 ) ;

print ( x . max ( ) ) ; // 6

x = new Array ( ) ;

print ( x . constructor === Array ) ; // true

# include < stdio . h >

# include < malloc . h >    //包含了malloc函数

# include < stdlib . h >    //包含了exit函数

//定义了一个数据类型，该数据类型的名字叫做struct Arr, 该数据类型含有三个成员，分别是pBase, len, cnt

struct Arr

{

int * pBase ; //存储的是数组第一个元素的地址

int len ; //数组所能容纳的最大元素的个数

int cnt ; //当前数组有效元素的个数

} ;

void init_arr ( struct Arr * , int ) ;    //初始化数组

bool is_empty ( struct Arr * ) ; // 数组是否为空

bool is_full ( struct Arr * ) ; // 数组是否已满

bool push ( struct Arr * , int ) ; //追加元素

void sort ( struct Arr * ) ; // 排序

void reverse ( struct Arr * ) ; // 逆序

bool insert ( struct Arr * , int , int ) ; // 插入元素

bool del ( struct Arr * , int , int * ) ; // 删除元素

void show_arr ( struct Arr * ) ; // 打印数组

int main ( void ) {

struct Arr arr ;

int val ; // 存储删除元素

init_arr ( & arr , 6 ) ; // 初始化数组

show_arr ( & arr ) ;

push ( & arr , 4 ) ; // 在尾部追加元素

push ( & arr , 1 ) ;

push ( & arr , - 1 ) ;

push ( & arr , 10 ) ;

push ( & arr , 0 ) ;

push ( & arr , 6 ) ;

show_arr ( & arr ) ;

sort ( & arr ) ; // 排序

show_arr ( & arr ) ;

reverse ( & arr ) ; // 逆序

show_arr ( & arr ) ;

del ( & arr , 4 , & val ) ; // 删除指定位置元素

printf ( "您删除的元素是: %d/n" , val ) ;

show_arr ( & arr ) ;

insert ( & arr , 4 , 20 ) ; // 在指定位置插入元素

show_arr ( & arr ) ;

return 0 ;

}

void init_arr ( struct Arr * pArr , int length ) {

pArr -> pBase = ( int * ) malloc ( sizeof ( int ) * length ) ;

if ( NULL == pArr -> pBase ) {

printf ( "动态内存分配失败!/n" ) ;

exit ( - 1 ) ; //终止整个程序

}

else {

pArr -> len = length ;

pArr -> cnt = 0 ;

}

return ;

}

bool is_empty ( struct Arr * pArr ) {

if ( 0 == pArr -> cnt ) {

return true ;

} else {

return false ;   

}       

}

bool is_full ( struct Arr * pArr ) {

if ( pArr -> cnt == pArr -> len ) {

return true ;

} else {

return false ;

}

}

void show_arr ( struct Arr * pArr ) {

if ( is_empty ( pArr ) ) {

printf ( "数组为空!/n" ) ;

} else {

for ( int i = 0 ; i < pArr -> cnt ; ++ i ) {

printf ( "%d  " , pArr -> pBase [ i ] ) ;

}

printf ( "/n" ) ;

}

}

bool push ( struct Arr * pArr , int val ) {

//满了就返回false

if ( is_full ( pArr ) ) {

return false ;

}

//不满时追加

pArr -> pBase [ pArr -> cnt ] = val ;

( pArr -> cnt ) ++ ;

return true ;

}

void sort ( struct Arr * pArr ) {

int i , j , t ;

// 简单的冒泡排序法实现，后面的章节会单独讲排序算法

for ( i = 0 ; i < pArr -> cnt ; ++ i ) {

for ( j = i + 1 ; j < pArr -> cnt ; ++ j ) {

if ( pArr -> pBase [ i ] > pArr -> pBase [ j ] ) {

t = pArr -> pBase [ i ] ;

pArr -> pBase [ i ] = pArr -> pBase [ j ] ;

pArr -> pBase [ j ] = t ;

}

}

}

}

void reverse ( struct Arr * pArr ) {

int i = 0 ;

int j = pArr -> cnt - 1 ;

int t ;

// 当i<j时，置换i和j位置的元素

while ( i < j ) {

t = pArr -> pBase [ i ] ;

pArr -> pBase [ i ] = pArr -> pBase [ j ] ;

pArr -> pBase [ j ] = t ;

++ i ;

-- j ;

}

return ;

}

bool insert ( struct Arr * pArr , int pos , int val ) {

int i ;

// 满了就算了

if ( is_full ( pArr ) ) {

return false ;

}

// 如果插入的位置不在数组有效范围内就算了

if ( pos < 1 || pos > pArr -> cnt + 1 ) {

return false ;

}

// 从插入位置开始后移各元素，将插入位置空出

for ( i = pArr -> cnt - 1 ; i >= pos - 1 ; -- i ) {

pArr -> pBase [ i + 1 ] = pArr -> pBase [ i ] ;

}

// 给插入位置的元素赋值

pArr -> pBase [ pos - 1 ] = val ;

//数组有效长度自增

( pArr -> cnt ) ++ ;

return true ;

}

bool del ( struct Arr * pArr , int pos , int * pVal ) {

int i ;

// 空就算了

if ( is_empty ( pArr ) ) {

return false ;

}

// 不在有效范围内就算了

if ( pos < 1 || pos > pArr -> cnt ) {

return false ;

}

// 存储被删除元素

* pVal = pArr -> pBase [ pos - 1 ] ;

// 从删除位置开始，前移各元素，将删除位置堵死

for ( i = pos ; i < pArr -> cnt ; ++ i ) {

pArr -> pBase [ i - 1 ] = pArr -> pBase [ i ] ;

}

// 数组有效长度自减

pArr -> cnt -- ;

return true ;

}